From d10e812c084252e9b83aef18da1a60428e3f4122 Mon Sep 17 00:00:00 2001 From: Keefer Taylor Date: Mon, 20 Sep 2021 16:06:13 -0700 Subject: [PATCH] Initial commit --- .github/workflows/ci.yml | 69 + README.md | 9 + deploy/.eslintignore | 8 + deploy/.eslintrc.js | 98 + deploy/.prettierignore | 1 + deploy/.prettierrc.js | 8 + deploy/README.md | 19 + deploy/package-lock.json | 7344 +++++++++++++++++ deploy/package.json | 52 + deploy/src/deploy-contracts.ts | 457 + deploy/src/utils.ts | 185 + deploy/tsconfig.eslint.json | 10 + deploy/tsconfig.json | 18 + smart_contracts/README.md | 14 + smart_contracts/common/constants.py | 16 + smart_contracts/common/errors.py | 80 + smart_contracts/common/oven-api.py | 131 + smart_contracts/compile.sh | 79 + smart_contracts/dev-fund.py | 395 + smart_contracts/dev-fund.tz | 177 + smart_contracts/end-to-end-tests.py | 783 ++ smart_contracts/minter.py | 2501 ++++++ smart_contracts/minter.tz | 3807 +++++++++ smart_contracts/oracle.py | 421 + smart_contracts/oracle.tz | 279 + smart_contracts/oven-factory.py | 644 ++ smart_contracts/oven-factory.tz | 946 +++ smart_contracts/oven-proxy.py | 1967 +++++ smart_contracts/oven-proxy.tz | 1068 +++ smart_contracts/oven-registry.py | 319 + smart_contracts/oven-registry.tz | 140 + smart_contracts/oven.py | 666 ++ smart_contracts/oven.tz | 544 ++ smart_contracts/stability-fund.py | 239 + smart_contracts/stability-fund.tz | 269 + smart_contracts/test-helpers/addresses.py | 54 + smart_contracts/test-helpers/compile.sh | 74 + .../test-helpers/dummy-contract.py | 32 + .../test-helpers/dummy-contract.tz | 34 + .../test-helpers/fake-harbinger.py | 37 + .../test-helpers/fake-harbinger.tz | 39 + smart_contracts/test-helpers/mock-minter.py | 136 + smart_contracts/test-helpers/mock-minter.tz | 1348 +++ .../test-helpers/mock-oven-proxy.py | 146 + .../test-helpers/mock-oven-proxy.tz | 1432 ++++ smart_contracts/token.py | 573 ++ smart_contracts/token.tz | 1125 +++ 47 files changed, 28793 insertions(+) create mode 100644 .github/workflows/ci.yml create mode 100644 README.md create mode 100644 deploy/.eslintignore create mode 100644 deploy/.eslintrc.js create mode 100644 deploy/.prettierignore create mode 100644 deploy/.prettierrc.js create mode 100644 deploy/README.md create mode 100644 deploy/package-lock.json create mode 100644 deploy/package.json create mode 100644 deploy/src/deploy-contracts.ts create mode 100644 deploy/src/utils.ts create mode 100644 deploy/tsconfig.eslint.json create mode 100644 deploy/tsconfig.json create mode 100644 smart_contracts/README.md create mode 100644 smart_contracts/common/constants.py create mode 100644 smart_contracts/common/errors.py create mode 100644 smart_contracts/common/oven-api.py create mode 100755 smart_contracts/compile.sh create mode 100644 smart_contracts/dev-fund.py create mode 100644 smart_contracts/dev-fund.tz create mode 100644 smart_contracts/end-to-end-tests.py create mode 100644 smart_contracts/minter.py create mode 100644 smart_contracts/minter.tz create mode 100644 smart_contracts/oracle.py create mode 100644 smart_contracts/oracle.tz create mode 100644 smart_contracts/oven-factory.py create mode 100644 smart_contracts/oven-factory.tz create mode 100644 smart_contracts/oven-proxy.py create mode 100644 smart_contracts/oven-proxy.tz create mode 100644 smart_contracts/oven-registry.py create mode 100644 smart_contracts/oven-registry.tz create mode 100644 smart_contracts/oven.py create mode 100644 smart_contracts/oven.tz create mode 100644 smart_contracts/stability-fund.py create mode 100644 smart_contracts/stability-fund.tz create mode 100644 smart_contracts/test-helpers/addresses.py create mode 100755 smart_contracts/test-helpers/compile.sh create mode 100644 smart_contracts/test-helpers/dummy-contract.py create mode 100644 smart_contracts/test-helpers/dummy-contract.tz create mode 100644 smart_contracts/test-helpers/fake-harbinger.py create mode 100644 smart_contracts/test-helpers/fake-harbinger.tz create mode 100644 smart_contracts/test-helpers/mock-minter.py create mode 100644 smart_contracts/test-helpers/mock-minter.tz create mode 100644 smart_contracts/test-helpers/mock-oven-proxy.py create mode 100644 smart_contracts/test-helpers/mock-oven-proxy.tz create mode 100644 smart_contracts/token.py create mode 100644 smart_contracts/token.tz diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..d418548a --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,69 @@ +name: Build + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + notify_init: + runs-on: ubuntu-latest + steps: + - name: Add SHORT_SHA env property with commit short sha + run: echo "SHORT_SHA=`echo ${GITHUB_SHA} | cut -c1-7`" >> $GITHUB_ENV + - name: Discord notification PR + env: + DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }} + uses: Ilshidur/action-discord@master + with: + args: > + <:kolibri:790471932025372693> [[{{ SHORT_SHA }}](https://github.com/{{ GITHUB_REPOSITORY }}/commit/{{ SHORT_SHA }})] [Starting Kolibri Contracts build...](https://github.com/{{ GITHUB_REPOSITORY }}/actions/runs/{{ GITHUB_RUN_ID }}?check_suite_focus=true) + ```${{ github.event.head_commit.message }}``` + + build_and_test_smart_contracts: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + - uses: actions/setup-python@v2 + - name: "Install SmartPy" + run: | + curl -s https://smartpy.io/releases/20201222-65067da80037a151c726ae887cc2a24d02eca2b0/cli/install.sh | sh -s -- local-install ~/smartpy-cli + - name: "Build and Test Smart Contracts" + run: | + cd smart_contracts + ./compile.sh + + lint_and_build_deploy_scripts: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + - name: "Install Dependencies" + run: | + sudo apt-get update && sudo apt-get install build-essential git libusb-1.0-0 libusb-1.0-0-dev libudev-dev + - name: "Build and lint deploy scripts" + run: | + cd deploy + npm i + npm run lint + npm run build + + notify_complete: + runs-on: ubuntu-latest + needs: + - notify_init + - build_and_test_smart_contracts + - lint_and_build_deploy_scripts + steps: + - name: Add SHORT_SHA env property with commit short sha + run: echo "SHORT_SHA=`echo ${GITHUB_SHA} | cut -c1-7`" >> $GITHUB_ENV + - name: Discord notification PR + env: + DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }} + uses: Ilshidur/action-discord@master + with: + args: > + <:kolibri:790471932025372693> [[{{ SHORT_SHA }}](https://github.com/{{ GITHUB_REPOSITORY }}/commit/{{ SHORT_SHA }})] [Kolibri Contracts built successfully!](https://github.com/{{ GITHUB_REPOSITORY }}/actions/runs/{{ GITHUB_RUN_ID }}?check_suite_focus=true) + ```${{ github.event.head_commit.message }}``` diff --git a/README.md b/README.md new file mode 100644 index 00000000..a4f87f63 --- /dev/null +++ b/README.md @@ -0,0 +1,9 @@ +# Kolibri + +## Directory Structure + +- `deploy/`: NPM package to deploy the system. +- `documentation/`: Documentation on the system, focused on smart contracts and high level concepts. +- `smart_contracts/`: SmartPy Smart Contracts and compiled michelson code +- `sdk/`: NPM Package to interact with stable coin system. +- `vue-frontend/`: Front end for Kolibri.finance \ No newline at end of file diff --git a/deploy/.eslintignore b/deploy/.eslintignore new file mode 100644 index 00000000..ae6e7e6a --- /dev/null +++ b/deploy/.eslintignore @@ -0,0 +1,8 @@ +# Do not lint submodules. +multisig-timelock + +# Do not lint generated files. +build + +# Do not lint node_modules +node_modules \ No newline at end of file diff --git a/deploy/.eslintrc.js b/deploy/.eslintrc.js new file mode 100644 index 00000000..7d0486f0 --- /dev/null +++ b/deploy/.eslintrc.js @@ -0,0 +1,98 @@ +module.exports = { + root: true, + rules: { + 'prefer-template': 2 + }, + + parser: '@typescript-eslint/parser', // Make ESLint compatible with TypeScript + parserOptions: { + // Enable linting rules with type information from our tsconfig + tsconfigRootDir: __dirname, + project: ['./tsconfig.eslint.json'], + + sourceType: 'module', // Allow the use of imports / ES modules + + ecmaFeatures: { + impliedStrict: true, // Enable global strict mode + }, + }, + + // Specify global variables that are predefined + env: { + browser: true, // Enable browser global variables + node: true, // Enable node global variables & Node.js scoping + es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020 + jest: true, // Add Jest testing global variables + }, + + plugins: [ + '@typescript-eslint', // Add some TypeScript specific rules, and disable rules covered by the typechecker + 'import', // Add rules that help validate proper imports + 'jest', // Add rules for writing better Jest tests + 'prettier', // Allows running prettier as an ESLint rule, and reporting differences as individual linting issues + ], + + extends: [ + // ESLint recommended rules + 'eslint:recommended', + + // Add TypeScript-specific rules, and disable rules covered by typechecker + 'plugin:@typescript-eslint/eslint-recommended', + 'plugin:@typescript-eslint/recommended', + + // Add rules for import/export syntax + 'plugin:import/errors', + 'plugin:import/warnings', + 'plugin:import/typescript', + + // Add rules for Jest-specific syntax + 'plugin:jest/recommended', + + // Add rules that specifically require type information using our tsconfig + 'plugin:@typescript-eslint/recommended-requiring-type-checking', + + // Enable Prettier for ESLint --fix, and disable rules that conflict with Prettier + 'prettier/@typescript-eslint', + 'plugin:prettier/recommended', + ], + + // rules: { + // // This rule is about explicitly using `return undefined` when a function returns any non-undefined object. + // // However, since we're using TypeScript, it will yell at us if a function is not allowed to return `undefined` in its signature, so we don't need this rule. + // "consistent-return": "off", + // }, + + overrides: [ + // Overrides for all test files + { + files: '__tests__/**/*.ts', + rules: { + // For our just test files, the pattern has been to have unnamed functions + 'func-names': 'off', + // Using non-null assertions (obj!.property) cancels the benefits of the strict null-checking mode, but these are test files, so we don't care. + '@typescript-eslint/no-non-null-assertion': 'off', + // For some test files, we shadow testing constants with function parameter names + 'no-shadow': 'off', + // Some of our test files declare helper classes with errors + 'max-classes-per-file': 'off', + }, + }, + { + files: '**/*.ts', + rules: { + // Allow unused variables in our files when explicitly prepended with `_`. + '@typescript-eslint/no-unused-vars': [ + 'error', + { argsIgnorePattern: '^_' }, + ], + + // Allow us to import computed values for GRPC package definitions + 'import/namespace': [2, { allowComputed: true }], + + // These rules are deprecated, but we have an old config that enables it + '@typescript-eslint/camelcase': 'off', + '@typescript-eslint/ban-ts-ignore': 'off', + }, + }, + ], +} diff --git a/deploy/.prettierignore b/deploy/.prettierignore new file mode 100644 index 00000000..712d7c4d --- /dev/null +++ b/deploy/.prettierignore @@ -0,0 +1 @@ +build/**/* diff --git a/deploy/.prettierrc.js b/deploy/.prettierrc.js new file mode 100644 index 00000000..39d3ecf8 --- /dev/null +++ b/deploy/.prettierrc.js @@ -0,0 +1,8 @@ +module.exports = { + tabWidth: 2, + printWidth: 80, + singleQuote: true, + semi: false, + trailingComma: "all", + arrowParens: "always", +}; \ No newline at end of file diff --git a/deploy/README.md b/deploy/README.md new file mode 100644 index 00000000..13754e4b --- /dev/null +++ b/deploy/README.md @@ -0,0 +1,19 @@ +# Deploy Scripts + +This NPM package allows stablecoin contracts to be deployed. + +## Rebuild Smart Contracts and Deploy +``` +npm run deploy +``` + +## Re-compile Contracts +``` +npm run build-smart-contracts +``` + +## Deploy without Rebuilding Smart Contracts +``` +npm run deploy-no-build +``` + diff --git a/deploy/package-lock.json b/deploy/package-lock.json new file mode 100644 index 00000000..f70696ca --- /dev/null +++ b/deploy/package-lock.json @@ -0,0 +1,7344 @@ +{ + "name": "kolibri-deploy", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "@babel/code-frame": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.10.4.tgz", + "integrity": "sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==", + "dev": true, + "requires": { + "@babel/highlight": "^7.10.4" + } + }, + "@babel/core": { + "version": "7.12.9", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.12.9.tgz", + "integrity": "sha512-gTXYh3M5wb7FRXQy+FErKFAv90BnlOuNn1QkCK2lREoPAjrQCO49+HVSrFoe5uakFAF5eenS75KbO2vQiLrTMQ==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.10.4", + "@babel/generator": "^7.12.5", + "@babel/helper-module-transforms": "^7.12.1", + "@babel/helpers": "^7.12.5", + "@babel/parser": "^7.12.7", + "@babel/template": "^7.12.7", + "@babel/traverse": "^7.12.9", + "@babel/types": "^7.12.7", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.1", + "json5": "^2.1.2", + "lodash": "^4.17.19", + "resolve": "^1.3.2", + "semver": "^5.4.1", + "source-map": "^0.5.0" + }, + "dependencies": { + "json5": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.3.tgz", + "integrity": "sha512-KXPvOm8K9IJKFM0bmdn8QXh7udDh1g/giieX0NLCaMnb4hEiVFqnop2ImTXCc5e0/oHz3LTqmHGtExn5hfMkOA==", + "dev": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "@babel/generator": { + "version": "7.12.5", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.12.5.tgz", + "integrity": "sha512-m16TQQJ8hPt7E+OS/XVQg/7U184MLXtvuGbCdA7na61vha+ImkyyNM/9DDA0unYCVZn3ZOhng+qz48/KBOT96A==", + "dev": true, + "requires": { + "@babel/types": "^7.12.5", + "jsesc": "^2.5.1", + "source-map": "^0.5.0" + }, + "dependencies": { + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "@babel/helper-function-name": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.10.4.tgz", + "integrity": "sha512-YdaSyz1n8gY44EmN7x44zBn9zQ1Ry2Y+3GTA+3vH6Mizke1Vw0aWDM66FOYEPw8//qKkmqOckrGgTYa+6sceqQ==", + "dev": true, + "requires": { + "@babel/helper-get-function-arity": "^7.10.4", + "@babel/template": "^7.10.4", + "@babel/types": "^7.10.4" + } + }, + "@babel/helper-get-function-arity": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.10.4.tgz", + "integrity": "sha512-EkN3YDB+SRDgiIUnNgcmiD361ti+AVbL3f3Henf6dqqUyr5dMsorno0lJWJuLhDhkI5sYEpgj6y9kB8AOU1I2A==", + "dev": true, + "requires": { + "@babel/types": "^7.10.4" + } + }, + "@babel/helper-member-expression-to-functions": { + "version": "7.12.7", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.12.7.tgz", + "integrity": "sha512-DCsuPyeWxeHgh1Dus7APn7iza42i/qXqiFPWyBDdOFtvS581JQePsc1F/nD+fHrcswhLlRc2UpYS1NwERxZhHw==", + "dev": true, + "requires": { + "@babel/types": "^7.12.7" + } + }, + "@babel/helper-module-imports": { + "version": "7.12.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.12.5.tgz", + "integrity": "sha512-SR713Ogqg6++uexFRORf/+nPXMmWIn80TALu0uaFb+iQIUoR7bOC7zBWyzBs5b3tBBJXuyD0cRu1F15GyzjOWA==", + "dev": true, + "requires": { + "@babel/types": "^7.12.5" + } + }, + "@babel/helper-module-transforms": { + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.12.1.tgz", + "integrity": "sha512-QQzehgFAZ2bbISiCpmVGfiGux8YVFXQ0abBic2Envhej22DVXV9nCFaS5hIQbkyo1AdGb+gNME2TSh3hYJVV/w==", + "dev": true, + "requires": { + "@babel/helper-module-imports": "^7.12.1", + "@babel/helper-replace-supers": "^7.12.1", + "@babel/helper-simple-access": "^7.12.1", + "@babel/helper-split-export-declaration": "^7.11.0", + "@babel/helper-validator-identifier": "^7.10.4", + "@babel/template": "^7.10.4", + "@babel/traverse": "^7.12.1", + "@babel/types": "^7.12.1", + "lodash": "^4.17.19" + } + }, + "@babel/helper-optimise-call-expression": { + "version": "7.12.7", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.7.tgz", + "integrity": "sha512-I5xc9oSJ2h59OwyUqjv95HRyzxj53DAubUERgQMrpcCEYQyToeHA+NEcUEsVWB4j53RDeskeBJ0SgRAYHDBckw==", + "dev": true, + "requires": { + "@babel/types": "^7.12.7" + } + }, + "@babel/helper-plugin-utils": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz", + "integrity": "sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==", + "dev": true + }, + "@babel/helper-replace-supers": { + "version": "7.12.5", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.12.5.tgz", + "integrity": "sha512-5YILoed0ZyIpF4gKcpZitEnXEJ9UoDRki1Ey6xz46rxOzfNMAhVIJMoune1hmPVxh40LRv1+oafz7UsWX+vyWA==", + "dev": true, + "requires": { + "@babel/helper-member-expression-to-functions": "^7.12.1", + "@babel/helper-optimise-call-expression": "^7.10.4", + "@babel/traverse": "^7.12.5", + "@babel/types": "^7.12.5" + } + }, + "@babel/helper-simple-access": { + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.12.1.tgz", + "integrity": "sha512-OxBp7pMrjVewSSC8fXDFrHrBcJATOOFssZwv16F3/6Xtc138GHybBfPbm9kfiqQHKhYQrlamWILwlDCeyMFEaA==", + "dev": true, + "requires": { + "@babel/types": "^7.12.1" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.11.0", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.11.0.tgz", + "integrity": "sha512-74Vejvp6mHkGE+m+k5vHY93FX2cAtrw1zXrZXRlG4l410Nm9PxfEiVTn1PjDPV5SnmieiueY4AFg2xqhNFuuZg==", + "dev": true, + "requires": { + "@babel/types": "^7.11.0" + } + }, + "@babel/helper-validator-identifier": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.10.4.tgz", + "integrity": "sha512-3U9y+43hz7ZM+rzG24Qe2mufW5KhvFg/NhnNph+i9mgCtdTCtMJuI1TMkrIUiK7Ix4PYlRF9I5dhqaLYA/ADXw==", + "dev": true + }, + "@babel/helpers": { + "version": "7.12.5", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.12.5.tgz", + "integrity": "sha512-lgKGMQlKqA8meJqKsW6rUnc4MdUk35Ln0ATDqdM1a/UpARODdI4j5Y5lVfUScnSNkJcdCRAaWkspykNoFg9sJA==", + "dev": true, + "requires": { + "@babel/template": "^7.10.4", + "@babel/traverse": "^7.12.5", + "@babel/types": "^7.12.5" + } + }, + "@babel/highlight": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.10.4.tgz", + "integrity": "sha512-i6rgnR/YgPEQzZZnbTHHuZdlE8qyoBNalD6F+q4vAFlcMEcqmkoG+mPqJYJCo63qPf74+Y1UZsl3l6f7/RIkmA==", + "dev": true, + "requires": { + "@babel/helper-validator-identifier": "^7.10.4", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "dependencies": { + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + } + } + }, + "@babel/parser": { + "version": "7.12.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.12.7.tgz", + "integrity": "sha512-oWR02Ubp4xTLCAqPRiNIuMVgNO5Aif/xpXtabhzW2HWUD47XJsAB4Zd/Rg30+XeQA3juXigV7hlquOTmwqLiwg==", + "dev": true + }, + "@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-class-properties": { + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.1.tgz", + "integrity": "sha512-U40A76x5gTwmESz+qiqssqmeEsKvcSyvtgktrm0uzcARAmM9I1jR221f6Oq+GmHrcD+LvZDag1UTOTe2fL3TeA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-top-level-await": { + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.1.tgz", + "integrity": "sha512-i7ooMZFS+a/Om0crxZodrTzNEPJHZrlMVGMTEpFAj6rYY/bKCddB0Dk/YxfPuYXOopuhKk/e1jV6h+WUU9XN3A==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/template": { + "version": "7.12.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.12.7.tgz", + "integrity": "sha512-GkDzmHS6GV7ZeXfJZ0tLRBhZcMcY0/Lnb+eEbXDBfCAcZCjrZKe6p3J4we/D24O9Y8enxWAg1cWwof59yLh2ow==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.10.4", + "@babel/parser": "^7.12.7", + "@babel/types": "^7.12.7" + } + }, + "@babel/traverse": { + "version": "7.12.9", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.12.9.tgz", + "integrity": "sha512-iX9ajqnLdoU1s1nHt36JDI9KG4k+vmI8WgjK5d+aDTwQbL2fUnzedNedssA645Ede3PM2ma1n8Q4h2ohwXgMXw==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.10.4", + "@babel/generator": "^7.12.5", + "@babel/helper-function-name": "^7.10.4", + "@babel/helper-split-export-declaration": "^7.11.0", + "@babel/parser": "^7.12.7", + "@babel/types": "^7.12.7", + "debug": "^4.1.0", + "globals": "^11.1.0", + "lodash": "^4.17.19" + }, + "dependencies": { + "globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true + } + } + }, + "@babel/types": { + "version": "7.12.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.12.7.tgz", + "integrity": "sha512-MNyI92qZq6jrQkXvtIiykvl4WtoRrVV9MPn+ZfsoEENjiWcBQ3ZSHrkxnJWgWtLX3XXqX5hrSQ+X69wkmesXuQ==", + "dev": true, + "requires": { + "@babel/helper-validator-identifier": "^7.10.4", + "lodash": "^4.17.19", + "to-fast-properties": "^2.0.0" + } + }, + "@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true + }, + "@cnakazawa/watch": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@cnakazawa/watch/-/watch-1.0.4.tgz", + "integrity": "sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ==", + "dev": true, + "requires": { + "exec-sh": "^0.3.2", + "minimist": "^1.2.0" + } + }, + "@eslint/eslintrc": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.1.3.tgz", + "integrity": "sha512-4YVwPkANLeNtRjMekzux1ci8hIaH5eGKktGqR0d3LWsKNn5B2X/1Z6Trxy7jQXl9EBGE6Yj02O+t09FMeRllaA==", + "dev": true, + "requires": { + "ajv": "^6.12.4", + "debug": "^4.1.1", + "espree": "^7.3.0", + "globals": "^12.1.0", + "ignore": "^4.0.6", + "import-fresh": "^3.2.1", + "js-yaml": "^3.13.1", + "lodash": "^4.17.19", + "minimatch": "^3.0.4", + "strip-json-comments": "^3.1.1" + }, + "dependencies": { + "ignore": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz", + "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==", + "dev": true + } + } + }, + "@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dev": true, + "requires": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "dependencies": { + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + } + } + }, + "@istanbuljs/schema": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.2.tgz", + "integrity": "sha512-tsAQNx32a8CoFhjhijUIhI4kccIAgmGhy8LZMZgGfmXcpMbPRUqn5LWmgRttILi6yeGmBJd2xsPkFMs0PzgPCw==", + "dev": true + }, + "@jest/console": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-26.6.2.tgz", + "integrity": "sha512-IY1R2i2aLsLr7Id3S6p2BA82GNWryt4oSvEXLAKc+L2zdi89dSkE8xC1C+0kpATG4JhBJREnQOH7/zmccM2B0g==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^26.6.2", + "jest-util": "^26.6.2", + "slash": "^3.0.0" + } + }, + "@jest/core": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-26.6.3.tgz", + "integrity": "sha512-xvV1kKbhfUqFVuZ8Cyo+JPpipAHHAV3kcDBftiduK8EICXmTFddryy3P7NfZt8Pv37rA9nEJBKCCkglCPt/Xjw==", + "dev": true, + "requires": { + "@jest/console": "^26.6.2", + "@jest/reporters": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.4", + "jest-changed-files": "^26.6.2", + "jest-config": "^26.6.3", + "jest-haste-map": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-resolve-dependencies": "^26.6.3", + "jest-runner": "^26.6.3", + "jest-runtime": "^26.6.3", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "jest-watcher": "^26.6.2", + "micromatch": "^4.0.2", + "p-each-series": "^2.1.0", + "rimraf": "^3.0.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + } + } + }, + "@jest/environment": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-26.6.2.tgz", + "integrity": "sha512-nFy+fHl28zUrRsCeMB61VDThV1pVTtlEokBRgqPrcT1JNq4yRNIyTHfyht6PqtUvY9IsuLGTrbG8kPXjSZIZwA==", + "dev": true, + "requires": { + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2" + } + }, + "@jest/fake-timers": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-26.6.2.tgz", + "integrity": "sha512-14Uleatt7jdzefLPYM3KLcnUl1ZNikaKq34enpb5XG9i81JpppDb5muZvonvKyrl7ftEHkKS5L5/eB/kxJ+bvA==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@sinonjs/fake-timers": "^6.0.1", + "@types/node": "*", + "jest-message-util": "^26.6.2", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2" + } + }, + "@jest/globals": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-26.6.2.tgz", + "integrity": "sha512-85Ltnm7HlB/KesBUuALwQ68YTU72w9H2xW9FjZ1eL1U3lhtefjjl5c2MiUbpXt/i6LaPRvoOFJ22yCBSfQ0JIA==", + "dev": true, + "requires": { + "@jest/environment": "^26.6.2", + "@jest/types": "^26.6.2", + "expect": "^26.6.2" + } + }, + "@jest/reporters": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-26.6.2.tgz", + "integrity": "sha512-h2bW53APG4HvkOnVMo8q3QXa6pcaNt1HkwVsOPMBV6LD/q9oSpxNSYZQYkAnjdMjrJ86UuYeLo+aEZClV6opnw==", + "dev": true, + "requires": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.2", + "graceful-fs": "^4.2.4", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^4.0.3", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.0.2", + "jest-haste-map": "^26.6.2", + "jest-resolve": "^26.6.2", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", + "node-notifier": "^8.0.0", + "slash": "^3.0.0", + "source-map": "^0.6.0", + "string-length": "^4.0.1", + "terminal-link": "^2.0.0", + "v8-to-istanbul": "^7.0.0" + } + }, + "@jest/source-map": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-26.6.2.tgz", + "integrity": "sha512-YwYcCwAnNmOVsZ8mr3GfnzdXDAl4LaenZP5z+G0c8bzC9/dugL8zRmxZzdoTl4IaS3CryS1uWnROLPFmb6lVvA==", + "dev": true, + "requires": { + "callsites": "^3.0.0", + "graceful-fs": "^4.2.4", + "source-map": "^0.6.0" + } + }, + "@jest/test-result": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-26.6.2.tgz", + "integrity": "sha512-5O7H5c/7YlojphYNrK02LlDIV2GNPYisKwHm2QTKjNZeEzezCbwYs9swJySv2UfPMyZ0VdsmMv7jIlD/IKYQpQ==", + "dev": true, + "requires": { + "@jest/console": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + } + }, + "@jest/test-sequencer": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-26.6.3.tgz", + "integrity": "sha512-YHlVIjP5nfEyjlrSr8t/YdNfU/1XEt7c5b4OxcXCjyRhjzLYu/rO69/WHPuYcbCWkz8kAeZVZp2N2+IOLLEPGw==", + "dev": true, + "requires": { + "@jest/test-result": "^26.6.2", + "graceful-fs": "^4.2.4", + "jest-haste-map": "^26.6.2", + "jest-runner": "^26.6.3", + "jest-runtime": "^26.6.3" + } + }, + "@jest/transform": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-26.6.2.tgz", + "integrity": "sha512-E9JjhUgNzvuQ+vVAL21vlyfy12gP0GhazGgJC4h6qUt1jSdUXGWJ1wfu/X7Sd8etSgxV4ovT1pb9v5D6QW4XgA==", + "dev": true, + "requires": { + "@babel/core": "^7.1.0", + "@jest/types": "^26.6.2", + "babel-plugin-istanbul": "^6.0.0", + "chalk": "^4.0.0", + "convert-source-map": "^1.4.0", + "fast-json-stable-stringify": "^2.0.0", + "graceful-fs": "^4.2.4", + "jest-haste-map": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-util": "^26.6.2", + "micromatch": "^4.0.2", + "pirates": "^4.0.1", + "slash": "^3.0.0", + "source-map": "^0.6.1", + "write-file-atomic": "^3.0.0" + } + }, + "@jest/types": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-26.6.2.tgz", + "integrity": "sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^15.0.0", + "chalk": "^4.0.0" + } + }, + "@lapo/asn1js": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@lapo/asn1js/-/asn1js-1.1.0.tgz", + "integrity": "sha512-Lbv9WwWKsWydCc4iC3n11RmKXC7eIwdo3lEB5Em4qFAMkC69ZHWmuv4YvQjbubRGuyAlgGI2Gvu0NvCld7BJ0A==" + }, + "@ledgerhq/devices": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/devices/-/devices-5.23.0.tgz", + "integrity": "sha512-XR9qTwn14WwN8VSMsYD9NTX/TgkmrTnXEh0pIj6HMRZwFzBPzslExOcXuCm3V9ssgAEAxv3VevfV8UulvvZUXA==", + "requires": { + "@ledgerhq/errors": "^5.23.0", + "@ledgerhq/logs": "^5.23.0", + "rxjs": "^6.6.3" + } + }, + "@ledgerhq/errors": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/errors/-/errors-5.23.0.tgz", + "integrity": "sha512-qtpX8aFrUUlYfOMu7BxTvxqUa8CniE+tEBpVEjYUhVbFdVJjM4ouwJD++RtQkMAU2c5jE7xb12WnUnf5BlAgLQ==" + }, + "@ledgerhq/hw-transport": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/hw-transport/-/hw-transport-5.23.0.tgz", + "integrity": "sha512-ICTG3Bst62SkC+lYYFgpKk5G4bAOxeIvptXnTLOhf6VqeN7gdHfiRzZwNPnKzI2pxmcEVbBitgsxEIEQJmDKVA==", + "requires": { + "@ledgerhq/devices": "^5.23.0", + "@ledgerhq/errors": "^5.23.0", + "events": "^3.2.0" + } + }, + "@ledgerhq/hw-transport-node-hid": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/hw-transport-node-hid/-/hw-transport-node-hid-5.23.0.tgz", + "integrity": "sha512-9mNc66S0s0C1Q5s2Vs8dhfHk5SRHvNVF2OsvXv8ir5r2O2ew4FOclZONJaVdFLrHLtoaFmtt8Az1e2NO6Xc8RA==", + "requires": { + "@ledgerhq/devices": "^5.23.0", + "@ledgerhq/errors": "^5.23.0", + "@ledgerhq/hw-transport": "^5.23.0", + "@ledgerhq/hw-transport-node-hid-noevents": "^5.23.0", + "@ledgerhq/logs": "^5.23.0", + "lodash": "^4.17.20", + "node-hid": "^1.3.0", + "usb": "^1.6.3" + } + }, + "@ledgerhq/hw-transport-node-hid-noevents": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/hw-transport-node-hid-noevents/-/hw-transport-node-hid-noevents-5.23.0.tgz", + "integrity": "sha512-tJQRAosKxWu33U28Pu3XmrktafhA3Vdx83Jdw260NVpqWs6ImA7j0A6242FQzYFEi92II/02jsrW6OBZo8bNUA==", + "requires": { + "@ledgerhq/devices": "^5.23.0", + "@ledgerhq/errors": "^5.23.0", + "@ledgerhq/hw-transport": "^5.23.0", + "@ledgerhq/logs": "^5.23.0", + "node-hid": "^1.3.0" + } + }, + "@ledgerhq/logs": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/@ledgerhq/logs/-/logs-5.23.0.tgz", + "integrity": "sha512-88M8RkVHl44k6MAhfrYhx25opnJV24/2XpuTUVklID11f9rBdE+6RZ9OMs39dyX2sDv7TuzIPi5nTRoCqZMDYw==" + }, + "@nodelib/fs.scandir": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz", + "integrity": "sha512-eGmwYQn3gxo4r7jdQnkrrN6bY478C3P+a/y72IJukF8LjB6ZHeB3c+Ehacj3sYeSmUXGlnA67/PmbM9CVwL7Dw==", + "dev": true, + "requires": { + "@nodelib/fs.stat": "2.0.3", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz", + "integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==", + "dev": true + }, + "@nodelib/fs.walk": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz", + "integrity": "sha512-1V9XOY4rDW0rehzbrcqAmHnz8e7SKvX27gh8Gt2WgB0+pdzdiLV83p72kZPU+jvMbS1qU5mauP2iOvO8rhmurQ==", + "dev": true, + "requires": { + "@nodelib/fs.scandir": "2.1.3", + "fastq": "^1.6.0" + } + }, + "@sinonjs/commons": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.1.tgz", + "integrity": "sha512-892K+kWUUi3cl+LlqEWIDrhvLgdL79tECi8JZUyq6IviKy/DNhuzCRlbHUjxK89f4ypPMMaFnFuR9Ie6DoIMsw==", + "dev": true, + "requires": { + "type-detect": "4.0.8" + } + }, + "@sinonjs/fake-timers": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-6.0.1.tgz", + "integrity": "sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==", + "dev": true, + "requires": { + "@sinonjs/commons": "^1.7.0" + } + }, + "@tacoinfra/harbinger-lib": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@tacoinfra/harbinger-lib/-/harbinger-lib-1.5.0.tgz", + "integrity": "sha512-piNJUnnvcqLMYbr2Tjl53gK7vUMC1pRYqRcy9ULIIv/zzItIPsSv+pWtibZTOIxXDCWCHbhX58qwuk1kEpZelQ==", + "requires": { + "@lapo/asn1js": "1.1.0", + "@ledgerhq/hw-transport": "^5.15.0", + "@ledgerhq/hw-transport-node-hid": "^5.16.0", + "@taquito/michel-codec": "^6.3.3-beta.0", + "@types/cli-progress": "^3.7.0", + "@types/libsodium-wrappers": "^0.7.7", + "@types/node": "^14.0.6", + "@types/node-fetch": "^2.5.7", + "@types/secp256k1": "^4.0.1", + "aws-sdk": "^2.722.0", + "blakejs": "^1.1.0", + "bs58check": "^2.1.2", + "conseiljs": "5.0.4", + "conseiljs-softsigner": "5.0.3-beta.0", + "libsodium-wrappers": "^0.7.6", + "loglevel": "^1.6.8", + "node-fetch": "^2.6.0", + "secp256k1": "^4.0.2", + "ts-node": "^8.8.1", + "typescript": "^3.8.3", + "web-request": "^1.0.7" + }, + "dependencies": { + "@types/node": { + "version": "14.6.4", + "resolved": "https://registry.npmjs.org/@types/node/-/node-14.6.4.tgz", + "integrity": "sha512-Wk7nG1JSaMfMpoMJDKUsWYugliB2Vy55pdjLpmLixeyMi7HizW2I/9QoxsPCkXl3dO+ZOVqPumKaDUv5zJu2uQ==" + }, + "conseiljs": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/conseiljs/-/conseiljs-5.0.4.tgz", + "integrity": "sha512-xGCyFfWTdaeAr/DLSlFlDW1ea50G7y/7QEu+lJy+J9eClBDqIrAvnjiUmAVYZU+SS7DexKZm/fqSNU+h8okpCA==", + "requires": { + "big-integer": "1.6.48", + "blakejs": "1.1.0", + "bs58check": "2.1.2", + "jsonpath-plus": "4.0.0", + "moo": "0.5.0", + "nearley": "2.19.1" + } + }, + "conseiljs-softsigner": { + "version": "5.0.3-beta.0", + "resolved": "https://registry.npmjs.org/conseiljs-softsigner/-/conseiljs-softsigner-5.0.3-beta.0.tgz", + "integrity": "sha512-X8NSBG1Up2bzdxV4/24d094owUYP5nXetgNAgChU6zBx4b5bCVXXDcEHuGQcN/FJJE+z95s4nvMi1PQj8UqEmg==", + "requires": { + "bip39": "3.0.2", + "conseiljs": "5.0.3-beta.2", + "generate-password": "1.5.1", + "libsodium-wrappers-sumo": "0.7.6" + }, + "dependencies": { + "conseiljs": { + "version": "5.0.3-beta.2", + "resolved": "https://registry.npmjs.org/conseiljs/-/conseiljs-5.0.3-beta.2.tgz", + "integrity": "sha512-ABEf88zgbzyMq0OnM4WwNeJyJvKdKDDkjd20FlIZI8a+WN+IitsmZ2WM7c0SomScca9OuD2kui5LvR9/b1z6Hw==", + "requires": { + "big-integer": "1.6.48", + "blakejs": "1.1.0", + "bs58check": "2.1.2", + "jsonpath-plus": "4.0.0", + "moo": "0.5.0", + "nearley": "2.19.1" + } + } + } + }, + "ts-node": { + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-8.10.2.tgz", + "integrity": "sha512-ISJJGgkIpDdBhWVu3jufsWpK3Rzo7bdiIXJjQc0ynKxVOVcg2oIrf2H2cejminGrptVc6q6/uynAHNCuWGbpVA==", + "requires": { + "arg": "^4.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "source-map-support": "^0.5.17", + "yn": "3.1.1" + } + }, + "typescript": { + "version": "3.9.7", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.7.tgz", + "integrity": "sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw==" + } + } + }, + "@taquito/michel-codec": { + "version": "6.3.3-beta.0", + "resolved": "https://registry.npmjs.org/@taquito/michel-codec/-/michel-codec-6.3.3-beta.0.tgz", + "integrity": "sha512-1CD7X6sAUl+0Zt5t3/BT98YiAfq74R0qSIAHkzjbxV4oPL0ZJwyw4CWD4tY4RPRhxlCwj5rVr34oFhjgCCY/cA==" + }, + "@types/babel__core": { + "version": "7.1.12", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.12.tgz", + "integrity": "sha512-wMTHiiTiBAAPebqaPiPDLFA4LYPKr6Ph0Xq/6rq1Ur3v66HXyG+clfR9CNETkD7MQS8ZHvpQOtA53DLws5WAEQ==", + "dev": true, + "requires": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "@types/babel__generator": { + "version": "7.6.2", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.2.tgz", + "integrity": "sha512-MdSJnBjl+bdwkLskZ3NGFp9YcXGx5ggLpQQPqtgakVhsWK0hTtNYhjpZLlWQTviGTvF8at+Bvli3jV7faPdgeQ==", + "dev": true, + "requires": { + "@babel/types": "^7.0.0" + } + }, + "@types/babel__template": { + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.0.tgz", + "integrity": "sha512-NTPErx4/FiPCGScH7foPyr+/1Dkzkni+rHiYHHoTjvwou7AQzJkNeD60A9CXRy+ZEN2B1bggmkTMCDb+Mv5k+A==", + "dev": true, + "requires": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "@types/babel__traverse": { + "version": "7.0.16", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.0.16.tgz", + "integrity": "sha512-S63Dt4CZOkuTmpLGGWtT/mQdVORJOpx6SZWGVaP56dda/0Nx5nEe82K7/LAm8zYr6SfMq+1N2OreIOrHAx656w==", + "dev": true, + "requires": { + "@babel/types": "^7.3.0" + } + }, + "@types/cli-progress": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/@types/cli-progress/-/cli-progress-3.8.0.tgz", + "integrity": "sha512-2OV7ybuYQc6ju6Xlg8ncQcPA/vVbMTSGS0vygjszi9O7swC63S6f2oAnP4CE+4ppRo7eCQovlj268KySt1MaUQ==", + "requires": { + "@types/node": "*" + } + }, + "@types/color-name": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz", + "integrity": "sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==", + "dev": true + }, + "@types/graceful-fs": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.4.tgz", + "integrity": "sha512-mWA/4zFQhfvOA8zWkXobwJvBD7vzcxgrOQ0J5CH1votGqdq9m7+FwtGaqyCZqC3NyyBkc9z4m+iry4LlqcMWJg==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "@types/istanbul-lib-coverage": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz", + "integrity": "sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw==", + "dev": true + }, + "@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "*" + } + }, + "@types/istanbul-reports": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.0.tgz", + "integrity": "sha512-nwKNbvnwJ2/mndE9ItP/zc2TCzw6uuodnF4EHYWD+gCQDVBuRQL5UzbZD0/ezy1iKsFU2ZQiDqg4M9dN4+wZgA==", + "dev": true, + "requires": { + "@types/istanbul-lib-report": "*" + } + }, + "@types/json-schema": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.6.tgz", + "integrity": "sha512-3c+yGKvVP5Y9TYBEibGNR+kLtijnj7mYrXRg+WpFb2X9xm04g/DXYkfg4hmzJQosc9snFNUPkbYIhu+KAm6jJw==", + "dev": true + }, + "@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha1-7ihweulOEdK4J7y+UnC86n8+ce4=", + "dev": true + }, + "@types/libsodium-wrappers": { + "version": "0.7.7", + "resolved": "https://registry.npmjs.org/@types/libsodium-wrappers/-/libsodium-wrappers-0.7.7.tgz", + "integrity": "sha512-Li91pVKcLvQJK3ZolwCPo85oxf2gKBCApgnesRxYg4OVYchLXcJB2eivX8S87vfQVv6ZRnyCO1lLDosZGJfpRg==" + }, + "@types/node": { + "version": "11.11.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-11.11.6.tgz", + "integrity": "sha512-Exw4yUWMBXM3X+8oqzJNRqZSwUAaS4+7NdvHqQuFi/d+synz++xmX3QIf+BFqneW8N31R8Ky+sikfZUXq07ggQ==" + }, + "@types/node-fetch": { + "version": "2.5.7", + "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.7.tgz", + "integrity": "sha512-o2WVNf5UhWRkxlf6eq+jMZDu7kjgpgJfl4xVNlvryc95O/6F2ld8ztKX+qu+Rjyet93WAWm5LjeX9H5FGkODvw==", + "requires": { + "@types/node": "*", + "form-data": "^3.0.0" + } + }, + "@types/normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-f5j5b/Gf71L+dbqxIpQ4Z2WlmI/mPJ0fOkGGmFgtb6sAu97EPczzbS3/tJKxmcYDj55OX6ssqwDAWOHIYDRDGA==", + "dev": true + }, + "@types/prettier": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.1.5.tgz", + "integrity": "sha512-UEyp8LwZ4Dg30kVU2Q3amHHyTn1jEdhCIE59ANed76GaT1Vp76DD3ZWSAxgCrw6wJ0TqeoBpqmfUHiUDPs//HQ==", + "dev": true + }, + "@types/secp256k1": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.1.tgz", + "integrity": "sha512-+ZjSA8ELlOp8SlKi0YLB2tz9d5iPNEmOBd+8Rz21wTMdaXQIa9b6TEnD6l5qKOCypE7FSyPyck12qZJxSDNoog==", + "requires": { + "@types/node": "*" + } + }, + "@types/stack-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.0.tgz", + "integrity": "sha512-RJJrrySY7A8havqpGObOB4W92QXKJo63/jFLLgpvOtsGUqbQZ9Sbgl35KMm1DjC6j7AvmmU2bIno+3IyEaemaw==", + "dev": true + }, + "@types/yargs": { + "version": "15.0.11", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-15.0.11.tgz", + "integrity": "sha512-jfcNBxHFYJ4nPIacsi3woz1+kvUO6s1CyeEhtnDHBjHUMNj5UlW2GynmnSgiJJEdNg9yW5C8lfoNRZrHGv5EqA==", + "dev": true, + "requires": { + "@types/yargs-parser": "*" + } + }, + "@types/yargs-parser": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-15.0.0.tgz", + "integrity": "sha512-FA/BWv8t8ZWJ+gEOnLLd8ygxH/2UFbAvgEonyfN6yWGLKc7zVjbpl2Y4CTjid9h2RfgPP6SEt6uHwEOply00yw==", + "dev": true + }, + "@typescript-eslint/eslint-plugin": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.9.0.tgz", + "integrity": "sha512-WrVzGMzzCrgrpnQMQm4Tnf+dk+wdl/YbgIgd5hKGa2P+lnJ2MON+nQnbwgbxtN9QDLi8HO+JAq0/krMnjQK6Cw==", + "dev": true, + "requires": { + "@typescript-eslint/experimental-utils": "4.9.0", + "@typescript-eslint/scope-manager": "4.9.0", + "debug": "^4.1.1", + "functional-red-black-tree": "^1.0.1", + "regexpp": "^3.0.0", + "semver": "^7.3.2", + "tsutils": "^3.17.1" + }, + "dependencies": { + "@typescript-eslint/experimental-utils": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.9.0.tgz", + "integrity": "sha512-0p8GnDWB3R2oGhmRXlEnCvYOtaBCijtA5uBfH5GxQKsukdSQyI4opC4NGTUb88CagsoNQ4rb/hId2JuMbzWKFQ==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.3", + "@typescript-eslint/scope-manager": "4.9.0", + "@typescript-eslint/types": "4.9.0", + "@typescript-eslint/typescript-estree": "4.9.0", + "eslint-scope": "^5.0.0", + "eslint-utils": "^2.0.0" + } + }, + "@typescript-eslint/scope-manager": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.9.0.tgz", + "integrity": "sha512-q/81jtmcDtMRE+nfFt5pWqO0R41k46gpVLnuefqVOXl4QV1GdQoBWfk5REcipoJNQH9+F5l+dwa9Li5fbALjzg==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.9.0", + "@typescript-eslint/visitor-keys": "4.9.0" + } + }, + "@typescript-eslint/types": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.9.0.tgz", + "integrity": "sha512-luzLKmowfiM/IoJL/rus1K9iZpSJK6GlOS/1ezKplb7MkORt2dDcfi8g9B0bsF6JoRGhqn0D3Va55b+vredFHA==", + "dev": true + }, + "@typescript-eslint/typescript-estree": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.9.0.tgz", + "integrity": "sha512-rmDR++PGrIyQzAtt3pPcmKWLr7MA+u/Cmq9b/rON3//t5WofNR4m/Ybft2vOLj0WtUzjn018ekHjTsnIyBsQug==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.9.0", + "@typescript-eslint/visitor-keys": "4.9.0", + "debug": "^4.1.1", + "globby": "^11.0.1", + "is-glob": "^4.0.1", + "lodash": "^4.17.15", + "semver": "^7.3.2", + "tsutils": "^3.17.1" + } + }, + "@typescript-eslint/visitor-keys": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.9.0.tgz", + "integrity": "sha512-sV45zfdRqQo1A97pOSx3fsjR+3blmwtdCt8LDrXgCX36v4Vmz4KHrhpV6Fo2cRdXmyumxx11AHw0pNJqCNpDyg==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.9.0", + "eslint-visitor-keys": "^2.0.0" + } + } + } + }, + "@typescript-eslint/experimental-utils": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.0.1.tgz", + "integrity": "sha512-gAqOjLiHoED79iYTt3F4uSHrYmg/GPz/zGezdB0jAdr6S6gwNiR/j7cTZ8nREKVzMVKLd9G3xbg1sV9GClW3sw==", + "dev": true, + "requires": { + "@types/json-schema": "^7.0.3", + "@typescript-eslint/scope-manager": "4.0.1", + "@typescript-eslint/types": "4.0.1", + "@typescript-eslint/typescript-estree": "4.0.1", + "eslint-scope": "^5.0.0", + "eslint-utils": "^2.0.0" + } + }, + "@typescript-eslint/parser": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.0.1.tgz", + "integrity": "sha512-1+qLmXHNAWSQ7RB6fdSQszAiA7JTwzakj5cNYjBTUmpH2cqilxMZEIV+DRKjVZs8NzP3ALmKexB0w/ExjcK9Iw==", + "dev": true, + "requires": { + "@typescript-eslint/scope-manager": "4.0.1", + "@typescript-eslint/types": "4.0.1", + "@typescript-eslint/typescript-estree": "4.0.1", + "debug": "^4.1.1" + } + }, + "@typescript-eslint/scope-manager": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.0.1.tgz", + "integrity": "sha512-u3YEXVJ8jsj7QCJk3om0Y457fy2euEOkkzxIB/LKU3MdyI+FJ2gI0M4aKEaXzwCSfNDiZ13a3lDo5DVozc+XLQ==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.0.1", + "@typescript-eslint/visitor-keys": "4.0.1" + } + }, + "@typescript-eslint/types": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.0.1.tgz", + "integrity": "sha512-S+gD3fgbkZYW2rnbjugNMqibm9HpEjqZBZkTiI3PwbbNGWmAcxolWIUwZ0SKeG4Dy2ktpKKaI/6+HGYVH8Qrlg==", + "dev": true + }, + "@typescript-eslint/typescript-estree": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.0.1.tgz", + "integrity": "sha512-zGzleORFXrRWRJAMLTB2iJD1IZbCPkg4hsI8mGdpYlKaqzvKYSEWVAYh14eauaR+qIoZVWrXgYSXqLtTlxotiw==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.0.1", + "@typescript-eslint/visitor-keys": "4.0.1", + "debug": "^4.1.1", + "globby": "^11.0.1", + "is-glob": "^4.0.1", + "lodash": "^4.17.15", + "semver": "^7.3.2", + "tsutils": "^3.17.1" + } + }, + "@typescript-eslint/visitor-keys": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.0.1.tgz", + "integrity": "sha512-yBSqd6FjnTzbg5RUy9J+9kJEyQjTI34JdGMJz+9ttlJzLCnGkBikxw+N5n2VDcc3CesbIEJ0MnZc5uRYnrEnCw==", + "dev": true, + "requires": { + "@typescript-eslint/types": "4.0.1", + "eslint-visitor-keys": "^2.0.0" + } + }, + "abab": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.5.tgz", + "integrity": "sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q==", + "dev": true + }, + "acorn": { + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.0.tgz", + "integrity": "sha512-+G7P8jJmCHr+S+cLfQxygbWhXy+8YTVGzAkpEbcLo2mLoL7tij/VG41QSHACSf5QgYRhMZYHuNc6drJaO0Da+w==", + "dev": true + }, + "acorn-globals": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz", + "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==", + "dev": true, + "requires": { + "acorn": "^7.1.1", + "acorn-walk": "^7.1.1" + } + }, + "acorn-jsx": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.2.0.tgz", + "integrity": "sha512-HiUX/+K2YpkpJ+SzBffkM/AQ2YE03S0U1kjTLVpoJdhZMOWy8qvXVN9JdLqv2QsaQ6MPYQIuNmwD8zOiYUofLQ==", + "dev": true + }, + "acorn-walk": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", + "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", + "dev": true + }, + "ajv": { + "version": "6.12.4", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.4.tgz", + "integrity": "sha512-eienB2c9qVQs2KWexhkrdMLVDoIQCz5KSeLxwg9Lzk4DOfBtIK9PQwwufcsn1jjGuf9WZmqPMbGxOzfcuphJCQ==", + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "dev": true + }, + "ansi-escapes": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz", + "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==", + "dev": true, + "requires": { + "type-fest": "^0.11.0" + }, + "dependencies": { + "type-fest": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz", + "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==", + "dev": true + } + } + }, + "ansi-regex": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "anymatch": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", + "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", + "dev": true, + "requires": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "aproba": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", + "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==" + }, + "are-we-there-yet": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz", + "integrity": "sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==", + "requires": { + "delegates": "^1.0.0", + "readable-stream": "^2.0.6" + }, + "dependencies": { + "readable-stream": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", + "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "~5.1.0" + } + } + } + }, + "arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==" + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "arr-diff": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", + "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", + "dev": true + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", + "dev": true + }, + "arr-union": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", + "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", + "dev": true + }, + "array-includes": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.1.tgz", + "integrity": "sha512-c2VXaCHl7zPsvpkFsw4nxvFie4fh1ur9bpcgsVkIjqn0H/Xwdg+7fv3n2r/isyS8EBj5b06M9kHyZuIr4El6WQ==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.0", + "is-string": "^1.0.5" + } + }, + "array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true + }, + "array-unique": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", + "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "array.prototype.flat": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.2.3.tgz", + "integrity": "sha512-gBlRZV0VSmfPIeWfuuy56XZMvbVfbEUnOXUvt3F/eUUUSyzlgLxhEX4YAEpxNAogRGehPSnfXyPtYyKAhkzQhQ==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.0-next.1" + } + }, + "asn1": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz", + "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==", + "requires": { + "safer-buffer": "~2.1.0" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "assign-symbols": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", + "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", + "dev": true + }, + "astral-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz", + "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==", + "dev": true + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + }, + "atob": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", + "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", + "dev": true + }, + "aws-sdk": { + "version": "2.748.0", + "resolved": "https://registry.npmjs.org/aws-sdk/-/aws-sdk-2.748.0.tgz", + "integrity": "sha512-H+DCioQ4AChoBxGMtagcJ3a0mM0lOh3ta/dWIrfPTECAlRIuxlrBDp78cRhPgvdYYUxW54kB/IaHGR2xPP8JXw==", + "requires": { + "buffer": "4.9.2", + "events": "1.1.1", + "ieee754": "1.1.13", + "jmespath": "0.15.0", + "querystring": "0.2.0", + "sax": "1.2.1", + "url": "0.10.3", + "uuid": "3.3.2", + "xml2js": "0.4.19" + }, + "dependencies": { + "buffer": { + "version": "4.9.2", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.2.tgz", + "integrity": "sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=" + } + } + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + }, + "aws4": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.10.1.tgz", + "integrity": "sha512-zg7Hz2k5lI8kb7U32998pRRFin7zJlkfezGJjUc2heaD4Pw2wObakCDVzkKztTm/Ln7eiVvYsjqak0Ed4LkMDA==" + }, + "babel-jest": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-26.6.3.tgz", + "integrity": "sha512-pl4Q+GAVOHwvjrck6jKjvmGhnO3jHX/xuB9d27f+EJZ/6k+6nMuPjorrYp7s++bKKdANwzElBWnLWaObvTnaZA==", + "dev": true, + "requires": { + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/babel__core": "^7.1.7", + "babel-plugin-istanbul": "^6.0.0", + "babel-preset-jest": "^26.6.2", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "slash": "^3.0.0" + } + }, + "babel-plugin-istanbul": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.0.0.tgz", + "integrity": "sha512-AF55rZXpe7trmEylbaE1Gv54wn6rwU03aptvRoVIGP8YykoSxqdVLV1TfwflBCE/QtHmqtP8SWlTENqbK8GCSQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^4.0.0", + "test-exclude": "^6.0.0" + } + }, + "babel-plugin-jest-hoist": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-26.6.2.tgz", + "integrity": "sha512-PO9t0697lNTmcEHH69mdtYiOIkkOlj9fySqfO3K1eCcdISevLAE0xY59VLLUj0SoiPiTX/JU2CYFpILydUa5Lw==", + "dev": true, + "requires": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.0.0", + "@types/babel__traverse": "^7.0.6" + } + }, + "babel-preset-current-node-syntax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.0.tgz", + "integrity": "sha512-mGkvkpocWJes1CmMKtgGUwCeeq0pOhALyymozzDWYomHTbDLwueDYG6p4TK1YOeYHCzBzYPsWkgTto10JubI1Q==", + "dev": true, + "requires": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + } + }, + "babel-preset-jest": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-26.6.2.tgz", + "integrity": "sha512-YvdtlVm9t3k777c5NPQIv6cxFFFapys25HiUmuSgHwIZhfifweR5c5Sf5nwE3MAbfu327CYSvps8Yx6ANLyleQ==", + "dev": true, + "requires": { + "babel-plugin-jest-hoist": "^26.6.2", + "babel-preset-current-node-syntax": "^1.0.0" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", + "dev": true + }, + "base": { + "version": "0.11.2", + "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", + "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", + "dev": true, + "requires": { + "cache-base": "^1.0.1", + "class-utils": "^0.3.5", + "component-emitter": "^1.2.1", + "define-property": "^1.0.0", + "isobject": "^3.0.1", + "mixin-deep": "^1.2.0", + "pascalcase": "^0.1.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "base-x": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.8.tgz", + "integrity": "sha512-Rl/1AWP4J/zRrk54hhlxH4drNxPJXYUaKffODVI53/dAsV4t9fBxyxYKAVPU1XBHxYwOWP9h9H0hM2MVw4YfJA==", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "base64-js": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz", + "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==" + }, + "bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", + "requires": { + "tweetnacl": "^0.14.3" + } + }, + "big-integer": { + "version": "1.6.48", + "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.48.tgz", + "integrity": "sha512-j51egjPa7/i+RdiRuJbPdJ2FIUYYPhvYLjzoYbcMMm62ooO6F94fETG4MTs46zPAF9Brs04OajboA/qTGuz78w==" + }, + "bindings": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", + "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", + "requires": { + "file-uri-to-path": "1.0.0" + } + }, + "bip39": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/bip39/-/bip39-3.0.2.tgz", + "integrity": "sha512-J4E1r2N0tUylTKt07ibXvhpT2c5pyAFgvuA5q1H9uDy6dEGpjV8jmymh3MTYJDLCNbIVClSB9FbND49I6N24MQ==", + "requires": { + "@types/node": "11.11.6", + "create-hash": "^1.1.0", + "pbkdf2": "^3.0.9", + "randombytes": "^2.0.1" + } + }, + "bl": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/bl/-/bl-4.0.3.tgz", + "integrity": "sha512-fs4G6/Hu4/EE+F75J8DuN/0IpQqNjAdC7aEQv7Qt8MHGUH7Ckv2MwTEEeN9QehD0pfIDkMI1bkHYkKy7xHyKIg==", + "requires": { + "buffer": "^5.5.0", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "blakejs": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/blakejs/-/blakejs-1.1.0.tgz", + "integrity": "sha1-ad+S75U6qIylGjLfarHFShVfx6U=" + }, + "bn.js": { + "version": "4.11.9", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.9.tgz", + "integrity": "sha512-E6QoYqCKZfgatHTdHzs1RRKP7ip4vvm+EyRUeE2RF0NblwVvb0p6jSVeNTOFxPn26QXN2o6SMfNxKp6kU8zQaw==" + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "requires": { + "fill-range": "^7.0.1" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=" + }, + "browser-process-hrtime": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz", + "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==", + "dev": true + }, + "bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha1-vhYedsNU9veIrkBx9j806MTwpCo=", + "requires": { + "base-x": "^3.0.2" + } + }, + "bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "requires": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dev": true, + "requires": { + "node-int64": "^0.4.0" + } + }, + "buffer": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.6.0.tgz", + "integrity": "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, + "buffer-from": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", + "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==" + }, + "cache-base": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", + "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", + "dev": true, + "requires": { + "collection-visit": "^1.0.0", + "component-emitter": "^1.2.1", + "get-value": "^2.0.6", + "has-value": "^1.0.0", + "isobject": "^3.0.1", + "set-value": "^2.0.0", + "to-object-path": "^0.3.0", + "union-value": "^1.0.0", + "unset-value": "^1.0.0" + } + }, + "callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true + }, + "capture-exit": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/capture-exit/-/capture-exit-2.0.0.tgz", + "integrity": "sha512-PiT/hQmTonHhl/HFGN+Lx3JJUznrVYJ3+AQsnthneZbvW7x+f08Tk7yLJTLEOUvBTbduLeeBkxEaYXUOUrRq6g==", + "dev": true, + "requires": { + "rsvp": "^4.8.4" + } + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "chalk": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz", + "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==", + "dev": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz", + "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==", + "dev": true, + "requires": { + "@types/color-name": "^1.1.1", + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true + }, + "chownr": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz", + "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==" + }, + "ci-info": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", + "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==", + "dev": true + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "cjs-module-lexer": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-0.6.0.tgz", + "integrity": "sha512-uc2Vix1frTfnuzxxu1Hp4ktSvM3QaI4oXl4ZUqL1wjTu/BGki9TrCWoqLTg/drR1KwAEarXuRFCG2Svr1GxPFw==", + "dev": true + }, + "class-utils": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", + "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", + "dev": true, + "requires": { + "arr-union": "^3.1.0", + "define-property": "^0.2.5", + "isobject": "^3.0.0", + "static-extend": "^0.1.1" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + } + } + }, + "cliui": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz", + "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==", + "dev": true, + "requires": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^6.2.0" + }, + "dependencies": { + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "string-width": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + } + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", + "dev": true + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=" + }, + "collect-v8-coverage": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", + "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==", + "dev": true + }, + "collection-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", + "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", + "dev": true, + "requires": { + "map-visit": "^1.0.0", + "object-visit": "^1.0.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, + "combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "requires": { + "delayed-stream": "~1.0.0" + } + }, + "commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" + }, + "component-emitter": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz", + "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", + "dev": true + }, + "conseiljs": { + "version": "5.0.5-beta.5", + "resolved": "https://registry.npmjs.org/conseiljs/-/conseiljs-5.0.5-beta.5.tgz", + "integrity": "sha512-uQdfhl/j4XSbq4oXiblG9WK0ODg6aIbEihlB43AiGbdbnSERsKqEZV5gML/MC785mTle0s0hmyIImTP/JYsg/Q==", + "requires": { + "big-integer": "1.6.48", + "blakejs": "1.1.0", + "bs58check": "2.1.2", + "jsonpath-plus": "4.0.0", + "moo": "0.5.0", + "nearley": "2.19.1" + } + }, + "conseiljs-softsigner": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/conseiljs-softsigner/-/conseiljs-softsigner-5.0.3.tgz", + "integrity": "sha512-+GOxiAv1wvkGvVuYuGzMdE3pdZ87L/3fpEndHwhK1CwPpPoshAUSTVyh81ch8sIu40uAv8n8g1RYWyB2Npg0Lw==", + "requires": { + "bip39": "3.0.2", + "conseiljs": "5.0.3", + "generate-password": "1.5.1", + "libsodium-wrappers-sumo": "0.7.6" + }, + "dependencies": { + "conseiljs": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/conseiljs/-/conseiljs-5.0.3.tgz", + "integrity": "sha512-TY6EBDDaGXBDNFOBqZe1HY+yNVNjJI/KLxqesrHzE7GTfxhneUttmXxcCer0KTg3WQSTw3T6ZnDpVXT7grMrkQ==", + "requires": { + "big-integer": "1.6.48", + "blakejs": "1.1.0", + "bs58check": "2.1.2", + "jsonpath-plus": "4.0.0", + "moo": "0.5.0", + "nearley": "2.19.1" + } + } + } + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=" + }, + "contains-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", + "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=", + "dev": true + }, + "convert-source-map": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz", + "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==", + "dev": true, + "requires": { + "safe-buffer": "~5.1.1" + }, + "dependencies": { + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + } + } + }, + "copy-descriptor": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", + "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", + "dev": true + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "cssom": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz", + "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw==", + "dev": true + }, + "cssstyle": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz", + "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==", + "dev": true, + "requires": { + "cssom": "~0.3.6" + }, + "dependencies": { + "cssom": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz", + "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==", + "dev": true + } + } + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "data-urls": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz", + "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==", + "dev": true, + "requires": { + "abab": "^2.0.3", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0" + } + }, + "debug": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", + "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", + "dev": true + }, + "decimal.js": { + "version": "10.2.1", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.2.1.tgz", + "integrity": "sha512-KaL7+6Fw6i5A2XSnsbhm/6B+NuEA7TZ4vqxnd5tXz9sbKtrN9Srj8ab4vKVdK8YAqZO9P1kg45Y6YLoduPf+kw==", + "dev": true + }, + "decode-uri-component": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", + "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", + "dev": true + }, + "decompress-response": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-4.2.1.tgz", + "integrity": "sha512-jOSne2qbyE+/r8G1VU+G/82LBs2Fs4LAsTiLSHOCOMZQl2OKZ6i8i4IyHemTe+/yIXOtTcRQMzPcgyhoFlqPkw==", + "requires": { + "mimic-response": "^2.0.0" + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==" + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "dev": true + }, + "deepmerge": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz", + "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==", + "dev": true + }, + "define-properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", + "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", + "dev": true, + "requires": { + "object-keys": "^1.0.12" + } + }, + "define-property": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", + "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", + "dev": true, + "requires": { + "is-descriptor": "^1.0.2", + "isobject": "^3.0.1" + }, + "dependencies": { + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=" + }, + "detect-libc": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz", + "integrity": "sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=" + }, + "detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true + }, + "diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==" + }, + "diff-sequences": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-26.6.2.tgz", + "integrity": "sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q==", + "dev": true + }, + "dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "requires": { + "path-type": "^4.0.0" + } + }, + "discontinuous-range": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/discontinuous-range/-/discontinuous-range-1.0.0.tgz", + "integrity": "sha1-44Mx8IRLukm5qctxx3FYWqsbxlo=" + }, + "doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, + "domexception": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz", + "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==", + "dev": true, + "requires": { + "webidl-conversions": "^5.0.0" + }, + "dependencies": { + "webidl-conversions": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz", + "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==", + "dev": true + } + } + }, + "ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", + "requires": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "elliptic": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.3.tgz", + "integrity": "sha512-IMqzv5wNQf+E6aHeIqATs0tOLeOTwj1QKbRcS3jBbYkl5oLAserA8yJTT7/VyHUYG91PRmPyeQDObKLPpeS4dw==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "emittery": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.7.2.tgz", + "integrity": "sha512-A8OG5SR/ij3SsJdWDJdkkSYUjQdCUx6APQXem0SaEePBSRg4eymGYwBkKo1Y6DU+af/Jn2dBQqDBvjnr9Vi8nQ==", + "dev": true + }, + "emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true + }, + "end-of-stream": { + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", + "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", + "requires": { + "once": "^1.4.0" + } + }, + "enquirer": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz", + "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==", + "dev": true, + "requires": { + "ansi-colors": "^4.1.1" + } + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.17.6", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.6.tgz", + "integrity": "sha512-Fr89bON3WFyUi5EvAeI48QTWX0AyekGgLA8H+c+7fbfCkJwRWRMLd8CQedNEyJuoYYhmtEqY92pgte1FAhBlhw==", + "dev": true, + "requires": { + "es-to-primitive": "^1.2.1", + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.1", + "is-callable": "^1.2.0", + "is-regex": "^1.1.0", + "object-inspect": "^1.7.0", + "object-keys": "^1.1.1", + "object.assign": "^4.1.0", + "string.prototype.trimend": "^1.0.1", + "string.prototype.trimstart": "^1.0.1" + } + }, + "es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=", + "dev": true + }, + "escodegen": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz", + "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==", + "dev": true, + "requires": { + "esprima": "^4.0.1", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + "source-map": "~0.6.1" + }, + "dependencies": { + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "dev": true, + "requires": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + } + }, + "optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "dev": true, + "requires": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + } + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=", + "dev": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "dev": true, + "requires": { + "prelude-ls": "~1.1.2" + } + } + } + }, + "eslint": { + "version": "7.8.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.8.1.tgz", + "integrity": "sha512-/2rX2pfhyUG0y+A123d0ccXtMm7DV7sH1m3lk9nk2DZ2LReq39FXHueR9xZwshE5MdfSf0xunSaMWRqyIA6M1w==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "@eslint/eslintrc": "^0.1.3", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.0.1", + "doctrine": "^3.0.0", + "enquirer": "^2.3.5", + "eslint-scope": "^5.1.0", + "eslint-utils": "^2.1.0", + "eslint-visitor-keys": "^1.3.0", + "espree": "^7.3.0", + "esquery": "^1.2.0", + "esutils": "^2.0.2", + "file-entry-cache": "^5.0.1", + "functional-red-black-tree": "^1.0.1", + "glob-parent": "^5.0.0", + "globals": "^12.1.0", + "ignore": "^4.0.6", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "js-yaml": "^3.13.1", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash": "^4.17.19", + "minimatch": "^3.0.4", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "progress": "^2.0.0", + "regexpp": "^3.1.0", + "semver": "^7.2.1", + "strip-ansi": "^6.0.0", + "strip-json-comments": "^3.1.0", + "table": "^5.2.3", + "text-table": "^0.2.0", + "v8-compile-cache": "^2.0.3" + }, + "dependencies": { + "eslint-visitor-keys": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz", + "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==", + "dev": true + }, + "ignore": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz", + "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==", + "dev": true + } + } + }, + "eslint-config-prettier": { + "version": "6.11.0", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-6.11.0.tgz", + "integrity": "sha512-oB8cpLWSAjOVFEJhhyMZh6NOEOtBVziaqdDQ86+qhDHFbZXoRTM7pNSvFRfW/W/L/LrQ38C99J5CGuRBBzBsdA==", + "dev": true, + "requires": { + "get-stdin": "^6.0.0" + } + }, + "eslint-import-resolver-node": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.4.tgz", + "integrity": "sha512-ogtf+5AB/O+nM6DIeBUNr2fuT7ot9Qg/1harBfBtaP13ekEWFQEEMP94BCB7zaNW3gyY+8SHYF00rnqYwXKWOA==", + "dev": true, + "requires": { + "debug": "^2.6.9", + "resolve": "^1.13.1" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-module-utils": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.6.0.tgz", + "integrity": "sha512-6j9xxegbqe8/kZY8cYpcp0xhbK0EgJlg3g9mib3/miLaExuuwc3n5UEfSnU6hWMbT0FAYVvDbL9RrRgpUeQIvA==", + "dev": true, + "requires": { + "debug": "^2.6.9", + "pkg-dir": "^2.0.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-plugin-import": { + "version": "2.22.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.22.0.tgz", + "integrity": "sha512-66Fpf1Ln6aIS5Gr/55ts19eUuoDhAbZgnr6UxK5hbDx6l/QgQgx61AePq+BV4PP2uXQFClgMVzep5zZ94qqsxg==", + "dev": true, + "requires": { + "array-includes": "^3.1.1", + "array.prototype.flat": "^1.2.3", + "contains-path": "^0.1.0", + "debug": "^2.6.9", + "doctrine": "1.5.0", + "eslint-import-resolver-node": "^0.3.3", + "eslint-module-utils": "^2.6.0", + "has": "^1.0.3", + "minimatch": "^3.0.4", + "object.values": "^1.1.1", + "read-pkg-up": "^2.0.0", + "resolve": "^1.17.0", + "tsconfig-paths": "^3.9.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "doctrine": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", + "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", + "dev": true, + "requires": { + "esutils": "^2.0.2", + "isarray": "^1.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "eslint-plugin-jest": { + "version": "24.1.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-jest/-/eslint-plugin-jest-24.1.3.tgz", + "integrity": "sha512-dNGGjzuEzCE3d5EPZQ/QGtmlMotqnYWD/QpCZ1UuZlrMAdhG5rldh0N0haCvhGnUkSeuORS5VNROwF9Hrgn3Lg==", + "dev": true, + "requires": { + "@typescript-eslint/experimental-utils": "^4.0.1" + } + }, + "eslint-plugin-mocha": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-mocha/-/eslint-plugin-mocha-8.0.0.tgz", + "integrity": "sha512-n67etbWDz6NQM+HnTwZHyBwz/bLlYPOxUbw7bPuCyFujv7ZpaT/Vn6KTAbT02gf7nRljtYIjWcTxK/n8a57rQQ==", + "dev": true, + "requires": { + "eslint-utils": "^2.1.0", + "ramda": "^0.27.1" + } + }, + "eslint-plugin-prettier": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-3.1.4.tgz", + "integrity": "sha512-jZDa8z76klRqo+TdGDTFJSavwbnWK2ZpqGKNZ+VvweMW516pDUMmQ2koXvxEE4JhzNvTv+radye/bWGBmA6jmg==", + "dev": true, + "requires": { + "prettier-linter-helpers": "^1.0.0" + } + }, + "eslint-scope": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.0.tgz", + "integrity": "sha512-iiGRvtxWqgtx5m8EyQUJihBloE4EnYeGE/bz1wSPwJE6tZuJUtHlhqDM4Xj2ukE8Dyy1+HCZ4hE0fzIVMzb58w==", + "dev": true, + "requires": { + "esrecurse": "^4.1.0", + "estraverse": "^4.1.1" + } + }, + "eslint-utils": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz", + "integrity": "sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==", + "dev": true, + "requires": { + "eslint-visitor-keys": "^1.1.0" + }, + "dependencies": { + "eslint-visitor-keys": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz", + "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==", + "dev": true + } + } + }, + "eslint-visitor-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz", + "integrity": "sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ==", + "dev": true + }, + "espree": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-7.3.0.tgz", + "integrity": "sha512-dksIWsvKCixn1yrEXO8UosNSxaDoSYpq9reEjZSbHLpT5hpaCAKTLBwq0RHtLrIr+c0ByiYzWT8KTMRzoRCNlw==", + "dev": true, + "requires": { + "acorn": "^7.4.0", + "acorn-jsx": "^5.2.0", + "eslint-visitor-keys": "^1.3.0" + }, + "dependencies": { + "eslint-visitor-keys": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz", + "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==", + "dev": true + } + } + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true + }, + "esquery": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.3.1.tgz", + "integrity": "sha512-olpvt9QG0vniUBZspVRN6lwB7hOZoTRtT+jzR+tS4ffYx2mzbw+z0XCOk44aaLYKApNX5nMm+E+P6o25ip/DHQ==", + "dev": true, + "requires": { + "estraverse": "^5.1.0" + }, + "dependencies": { + "estraverse": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz", + "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==", + "dev": true + } + } + }, + "esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "requires": { + "estraverse": "^5.2.0" + }, + "dependencies": { + "estraverse": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz", + "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==", + "dev": true + } + } + }, + "estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true + }, + "esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true + }, + "events": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.2.0.tgz", + "integrity": "sha512-/46HWwbfCX2xTawVfkKLGxMifJYQBWMwY1mjywRtb4c9x8l5NP3KoJtnIOiL1hfdRkIuYhETxQlo62IF8tcnlg==" + }, + "exec-sh": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/exec-sh/-/exec-sh-0.3.4.tgz", + "integrity": "sha512-sEFIkc61v75sWeOe72qyrqg2Qg0OuLESziUDk/O/z2qgS15y2gWVFrI6f2Qn/qw/0/NCfCEsmNA4zOjkwEZT1A==", + "dev": true + }, + "execa": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz", + "integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==", + "dev": true, + "requires": { + "cross-spawn": "^6.0.0", + "get-stream": "^4.0.0", + "is-stream": "^1.1.0", + "npm-run-path": "^2.0.0", + "p-finally": "^1.0.0", + "signal-exit": "^3.0.0", + "strip-eof": "^1.0.0" + }, + "dependencies": { + "cross-spawn": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", + "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==", + "dev": true, + "requires": { + "nice-try": "^1.0.4", + "path-key": "^2.0.1", + "semver": "^5.5.0", + "shebang-command": "^1.2.0", + "which": "^1.2.9" + } + }, + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "dev": true + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "dev": true, + "requires": { + "shebang-regex": "^1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", + "dev": true + }, + "which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + } + } + }, + "exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=", + "dev": true + }, + "expand-brackets": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", + "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", + "dev": true, + "requires": { + "debug": "^2.3.3", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "posix-character-classes": "^0.1.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "expand-template": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz", + "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==" + }, + "expect": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/expect/-/expect-26.6.2.tgz", + "integrity": "sha512-9/hlOBkQl2l/PLHJx6JjoDF6xPKcJEsUlWKb23rKE7KzeDqUZKXKNMW27KIue5JMdBV9HgmoJPcc8HtO85t9IA==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "ansi-styles": "^4.0.0", + "jest-get-type": "^26.3.0", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-regex-util": "^26.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + } + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + }, + "extend-shallow": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", + "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", + "dev": true, + "requires": { + "assign-symbols": "^1.0.0", + "is-extendable": "^1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4" + } + } + } + }, + "extglob": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", + "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", + "dev": true, + "requires": { + "array-unique": "^0.3.2", + "define-property": "^1.0.0", + "expand-brackets": "^2.1.4", + "extend-shallow": "^2.0.1", + "fragment-cache": "^0.2.1", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" + }, + "fast-diff": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz", + "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==", + "dev": true + }, + "fast-glob": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.4.tgz", + "integrity": "sha512-kr/Oo6PX51265qeuCYsyGypiO5uJFgBS0jksyG7FUeCyQzNwYnzrNIMR1NXfkZXsMYXYLRAHgISHBz8gQcxKHQ==", + "dev": true, + "requires": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.0", + "merge2": "^1.3.0", + "micromatch": "^4.0.2", + "picomatch": "^2.2.1" + } + }, + "fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==" + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "dev": true + }, + "fastq": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.8.0.tgz", + "integrity": "sha512-SMIZoZdLh/fgofivvIkmknUXyPnvxRE3DhtZ5Me3Mrsk5gyPL42F0xr51TdRXskBxHfMp+07bcYzfsYEsSQA9Q==", + "dev": true, + "requires": { + "reusify": "^1.0.4" + } + }, + "fb-watchman": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.1.tgz", + "integrity": "sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg==", + "dev": true, + "requires": { + "bser": "2.1.1" + } + }, + "file-entry-cache": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz", + "integrity": "sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g==", + "dev": true, + "requires": { + "flat-cache": "^2.0.1" + } + }, + "file-uri-to-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", + "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==" + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "dev": true, + "requires": { + "locate-path": "^2.0.0" + } + }, + "flat-cache": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-2.0.1.tgz", + "integrity": "sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA==", + "dev": true, + "requires": { + "flatted": "^2.0.0", + "rimraf": "2.6.3", + "write": "1.0.3" + } + }, + "flatted": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.2.tgz", + "integrity": "sha512-r5wGx7YeOwNWNlCA0wQ86zKyDLMQr+/RB8xy74M4hTphfmjlijTSSXGuH8rnvKZnfT9i+75zmd8jcKdMR4O6jA==", + "dev": true + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.0.tgz", + "integrity": "sha512-CKMFDglpbMi6PyN+brwB9Q/GOw0eAnsrEZDgcsH5Krhz5Od/haKHAX0NmQfha2zPPz0JpWzA7GJHGSnvCRLWsg==", + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + } + }, + "fragment-cache": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", + "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", + "dev": true, + "requires": { + "map-cache": "^0.2.2" + } + }, + "fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", + "dev": true + }, + "fsevents": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.2.1.tgz", + "integrity": "sha512-bTLYHSeC0UH/EFXS9KqWnXuOl/wHK5Z/d+ghd5AsFMYN7wIGkUCOJyzy88+wJKkZPGON8u4Z9f6U4FdgURE9qA==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", + "dev": true + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "requires": { + "aproba": "^1.0.3", + "console-control-strings": "^1.0.0", + "has-unicode": "^2.0.0", + "object-assign": "^4.1.0", + "signal-exit": "^3.0.0", + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1", + "wide-align": "^1.1.0" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "^1.0.0" + } + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "^1.0.0", + "is-fullwidth-code-point": "^1.0.0", + "strip-ansi": "^3.0.0" + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "^2.0.0" + } + } + } + }, + "generate-password": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/generate-password/-/generate-password-1.5.1.tgz", + "integrity": "sha512-XdsyfiF4mKoOEuzA44w9jSNav50zOurdWOV3V8DbA7SJIxR3Xm9ob14HKYTnMQOPX3ylqiJMnQF0wEa8gXZIMw==" + }, + "gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true + }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, + "get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true + }, + "get-stdin": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-6.0.0.tgz", + "integrity": "sha512-jp4tHawyV7+fkkSKyvjuLZswblUtz+SQKzSWnBbii16BuZksJlU1wuBYXY75r+duh/llF1ur6oNwi+2ZzjKZ7g==", + "dev": true + }, + "get-stream": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", + "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", + "dev": true, + "requires": { + "pump": "^3.0.0" + } + }, + "get-value": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", + "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", + "dev": true + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "github-from-package": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz", + "integrity": "sha1-l/tdlr/eiXMxPyDoKI75oWf6ZM4=" + }, + "glob": { + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", + "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-parent": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz", + "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==", + "dev": true, + "requires": { + "is-glob": "^4.0.1" + } + }, + "globals": { + "version": "12.4.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz", + "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==", + "dev": true, + "requires": { + "type-fest": "^0.8.1" + } + }, + "globby": { + "version": "11.0.1", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.1.tgz", + "integrity": "sha512-iH9RmgwCmUJHi2z5o2l3eTtGBtXek1OYlHrbcxOYugyHLmAsZrPj43OtHThd62Buh/Vv6VyCBD2bdyWcGNQqoQ==", + "dev": true, + "requires": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.1.1", + "ignore": "^5.1.4", + "merge2": "^1.3.0", + "slash": "^3.0.0" + } + }, + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true + }, + "growly": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/growly/-/growly-1.3.0.tgz", + "integrity": "sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE=", + "dev": true, + "optional": true + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + }, + "har-validator": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", + "requires": { + "ajv": "^6.12.3", + "har-schema": "^2.0.0" + } + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "has-symbols": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz", + "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==", + "dev": true + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=" + }, + "has-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", + "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", + "dev": true, + "requires": { + "get-value": "^2.0.6", + "has-values": "^1.0.0", + "isobject": "^3.0.0" + } + }, + "has-values": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", + "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "kind-of": "^4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "hash-base": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", + "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", + "requires": { + "inherits": "^2.0.4", + "readable-stream": "^3.6.0", + "safe-buffer": "^5.2.0" + } + }, + "hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "hosted-git-info": { + "version": "2.8.8", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz", + "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==", + "dev": true + }, + "html-encoding-sniffer": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz", + "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==", + "dev": true, + "requires": { + "whatwg-encoding": "^1.0.5" + } + }, + "html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "requires": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + } + }, + "human-signals": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", + "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", + "dev": true + }, + "iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "ieee754": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz", + "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==" + }, + "ignore": { + "version": "5.1.8", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz", + "integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==", + "dev": true + }, + "import-fresh": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.2.1.tgz", + "integrity": "sha512-6e1q1cnWP2RXD9/keSkxHScg508CdXqXWgWBaETNhyuBFz+kUZlKboh+ISK+bU++DmbHimVBrOz/zzPe0sZ3sQ==", + "dev": true, + "requires": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + } + }, + "import-local": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.0.2.tgz", + "integrity": "sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==", + "dev": true, + "requires": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "dependencies": { + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "requires": { + "find-up": "^4.0.0" + } + } + } + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "dev": true, + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "ini": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz", + "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==" + }, + "ip-regex": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/ip-regex/-/ip-regex-2.1.0.tgz", + "integrity": "sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=", + "dev": true + }, + "is-accessor-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", + "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", + "dev": true + }, + "is-callable": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.0.tgz", + "integrity": "sha512-pyVD9AaGLxtg6srb2Ng6ynWJqkHU9bEM087AKck0w8QwDarTfNcpIYoU8x8Hv2Icm8u6kFJM18Dag8lyqGkviw==", + "dev": true + }, + "is-ci": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz", + "integrity": "sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==", + "dev": true, + "requires": { + "ci-info": "^2.0.0" + } + }, + "is-core-module": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz", + "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "is-data-descriptor": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", + "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "is-date-object": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz", + "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==", + "dev": true + }, + "is-descriptor": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", + "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^0.1.6", + "is-data-descriptor": "^0.1.4", + "kind-of": "^5.0.0" + }, + "dependencies": { + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", + "dev": true + } + } + }, + "is-docker": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.1.1.tgz", + "integrity": "sha512-ZOoqiXfEwtGknTiuDEy8pN2CfE3TxMHprvNer1mXiqwkOT77Rw3YVrUQ52EqAOU3QAWDQ+bQdx7HJzrv7LS2Hw==", + "dev": true, + "optional": true + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", + "dev": true + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=" + }, + "is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "dev": true + }, + "is-glob": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz", + "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==", + "dev": true, + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true + }, + "is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "dev": true, + "requires": { + "isobject": "^3.0.1" + } + }, + "is-potential-custom-element-name": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.0.tgz", + "integrity": "sha1-DFLlS8yjkbssSUsh6GJtczbG45c=", + "dev": true + }, + "is-regex": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.1.tgz", + "integrity": "sha512-1+QkEcxiLlB7VEyFtyBg94e08OAsvq7FUBgApTq/w2ymCLyKJgDPsybBENVtA7XCQEgEXxKPonG+mvYRxh/LIg==", + "dev": true, + "requires": { + "has-symbols": "^1.0.1" + } + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=", + "dev": true + }, + "is-string": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz", + "integrity": "sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==", + "dev": true + }, + "is-symbol": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz", + "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==", + "dev": true, + "requires": { + "has-symbols": "^1.0.1" + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-windows": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", + "dev": true + }, + "is-wsl": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", + "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==", + "dev": true, + "optional": true, + "requires": { + "is-docker": "^2.0.0" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", + "dev": true + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", + "dev": true + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "istanbul-lib-coverage": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.0.0.tgz", + "integrity": "sha512-UiUIqxMgRDET6eR+o5HbfRYP1l0hqkWOs7vNxC/mggutCMUIhWMm8gAHb8tHlyfD3/l6rlgNA5cKdDzEAf6hEg==", + "dev": true + }, + "istanbul-lib-instrument": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz", + "integrity": "sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==", + "dev": true, + "requires": { + "@babel/core": "^7.7.5", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.0.0", + "semver": "^6.3.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", + "dev": true, + "requires": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + }, + "dependencies": { + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "istanbul-lib-source-maps": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.0.tgz", + "integrity": "sha512-c16LpFRkR8vQXyHZ5nLpY35JZtzj1PQY1iZmesUbf1FZHbIupcWfjgOXBY9YHkLEQ6puz1u4Dgj6qmU/DisrZg==", + "dev": true, + "requires": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + } + }, + "istanbul-reports": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.0.2.tgz", + "integrity": "sha512-9tZvz7AiR3PEDNGiV9vIouQ/EAcqMXFmkcA1CDFTwOB98OZVDL0PH9glHotf5Ugp6GCOTypfzGWI/OqjWNCRUw==", + "dev": true, + "requires": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + } + }, + "jest": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest/-/jest-26.6.3.tgz", + "integrity": "sha512-lGS5PXGAzR4RF7V5+XObhqz2KZIDUA1yD0DG6pBVmy10eh0ZIXQImRuzocsI/N2XZ1GrLFwTS27In2i2jlpq1Q==", + "dev": true, + "requires": { + "@jest/core": "^26.6.3", + "import-local": "^3.0.2", + "jest-cli": "^26.6.3" + }, + "dependencies": { + "jest-cli": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-26.6.3.tgz", + "integrity": "sha512-GF9noBSa9t08pSyl3CY4frMrqp+aQXFGFkf5hEPbh/pIUFYWMK6ZLTfbmadxJVcJrdRoChlWQsA2VkJcDFK8hg==", + "dev": true, + "requires": { + "@jest/core": "^26.6.3", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.4", + "import-local": "^3.0.2", + "is-ci": "^2.0.0", + "jest-config": "^26.6.3", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "prompts": "^2.0.1", + "yargs": "^15.4.1" + } + } + } + }, + "jest-changed-files": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-26.6.2.tgz", + "integrity": "sha512-fDS7szLcY9sCtIip8Fjry9oGf3I2ht/QT21bAHm5Dmf0mD4X3ReNUf17y+bO6fR8WgbIZTlbyG1ak/53cbRzKQ==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "execa": "^4.0.0", + "throat": "^5.0.0" + }, + "dependencies": { + "execa": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", + "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", + "dev": true, + "requires": { + "cross-spawn": "^7.0.0", + "get-stream": "^5.0.0", + "human-signals": "^1.1.1", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.0", + "onetime": "^5.1.0", + "signal-exit": "^3.0.2", + "strip-final-newline": "^2.0.0" + } + }, + "get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "requires": { + "pump": "^3.0.0" + } + }, + "is-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz", + "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==", + "dev": true + }, + "npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "requires": { + "path-key": "^3.0.0" + } + } + } + }, + "jest-config": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-26.6.3.tgz", + "integrity": "sha512-t5qdIj/bCj2j7NFVHb2nFB4aUdfucDn3JRKgrZnplb8nieAirAzRSHP8uDEd+qV6ygzg9Pz4YG7UTJf94LPSyg==", + "dev": true, + "requires": { + "@babel/core": "^7.1.0", + "@jest/test-sequencer": "^26.6.3", + "@jest/types": "^26.6.2", + "babel-jest": "^26.6.3", + "chalk": "^4.0.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.1", + "graceful-fs": "^4.2.4", + "jest-environment-jsdom": "^26.6.2", + "jest-environment-node": "^26.6.2", + "jest-get-type": "^26.3.0", + "jest-jasmine2": "^26.6.3", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "micromatch": "^4.0.2", + "pretty-format": "^26.6.2" + } + }, + "jest-diff": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-26.6.2.tgz", + "integrity": "sha512-6m+9Z3Gv9wN0WFVasqjCL/06+EFCMTqDEUl/b87HYK2rAPTyfz4ZIuSlPhY51PIQRWx5TaxeF1qmXKe9gfN3sA==", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "diff-sequences": "^26.6.2", + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" + } + }, + "jest-docblock": { + "version": "26.0.0", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-26.0.0.tgz", + "integrity": "sha512-RDZ4Iz3QbtRWycd8bUEPxQsTlYazfYn/h5R65Fc6gOfwozFhoImx+affzky/FFBuqISPTqjXomoIGJVKBWoo0w==", + "dev": true, + "requires": { + "detect-newline": "^3.0.0" + } + }, + "jest-each": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-26.6.2.tgz", + "integrity": "sha512-Mer/f0KaATbjl8MCJ+0GEpNdqmnVmDYqCTJYTvoo7rqmRiDllmp2AYN+06F93nXcY3ur9ShIjS+CO/uD+BbH4A==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "jest-get-type": "^26.3.0", + "jest-util": "^26.6.2", + "pretty-format": "^26.6.2" + } + }, + "jest-environment-jsdom": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-26.6.2.tgz", + "integrity": "sha512-jgPqCruTlt3Kwqg5/WVFyHIOJHsiAvhcp2qiR2QQstuG9yWox5+iHpU3ZrcBxW14T4fe5Z68jAfLRh7joCSP2Q==", + "dev": true, + "requires": { + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2", + "jsdom": "^16.4.0" + } + }, + "jest-environment-node": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-26.6.2.tgz", + "integrity": "sha512-zhtMio3Exty18dy8ee8eJ9kjnRyZC1N4C1Nt/VShN1apyXc8rWGtJ9lI7vqiWcyyXS4BVSEn9lxAM2D+07/Tag==", + "dev": true, + "requires": { + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2" + } + }, + "jest-get-type": { + "version": "26.3.0", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-26.3.0.tgz", + "integrity": "sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig==", + "dev": true + }, + "jest-haste-map": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-26.6.2.tgz", + "integrity": "sha512-easWIJXIw71B2RdR8kgqpjQrbMRWQBgiBwXYEhtGUTaX+doCjBheluShdDMeR8IMfJiTqH4+zfhtg29apJf/8w==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@types/graceful-fs": "^4.1.2", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "fsevents": "^2.1.2", + "graceful-fs": "^4.2.4", + "jest-regex-util": "^26.0.0", + "jest-serializer": "^26.6.2", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", + "micromatch": "^4.0.2", + "sane": "^4.0.3", + "walker": "^1.0.7" + } + }, + "jest-jasmine2": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-26.6.3.tgz", + "integrity": "sha512-kPKUrQtc8aYwBV7CqBg5pu+tmYXlvFlSFYn18ev4gPFtrRzB15N2gW/Roew3187q2w2eHuu0MU9TJz6w0/nPEg==", + "dev": true, + "requires": { + "@babel/traverse": "^7.1.0", + "@jest/environment": "^26.6.2", + "@jest/source-map": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "expect": "^26.6.2", + "is-generator-fn": "^2.0.0", + "jest-each": "^26.6.2", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-runtime": "^26.6.3", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "pretty-format": "^26.6.2", + "throat": "^5.0.0" + } + }, + "jest-leak-detector": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-26.6.2.tgz", + "integrity": "sha512-i4xlXpsVSMeKvg2cEKdfhh0H39qlJlP5Ex1yQxwF9ubahboQYMgTtz5oML35AVA3B4Eu+YsmwaiKVev9KCvLxg==", + "dev": true, + "requires": { + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" + } + }, + "jest-matcher-utils": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-26.6.2.tgz", + "integrity": "sha512-llnc8vQgYcNqDrqRDXWwMr9i7rS5XFiCwvh6DTP7Jqa2mqpcCBBlpCbn+trkG0KNhPu/h8rzyBkriOtBstvWhw==", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "jest-diff": "^26.6.2", + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" + } + }, + "jest-message-util": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-26.6.2.tgz", + "integrity": "sha512-rGiLePzQ3AzwUshu2+Rn+UMFk0pHN58sOG+IaJbk5Jxuqo3NYO1U2/MIR4S1sKgsoYSXSzdtSa0TgrmtUwEbmA==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "@jest/types": "^26.6.2", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "micromatch": "^4.0.2", + "pretty-format": "^26.6.2", + "slash": "^3.0.0", + "stack-utils": "^2.0.2" + } + }, + "jest-mock": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-26.6.2.tgz", + "integrity": "sha512-YyFjePHHp1LzpzYcmgqkJ0nm0gg/lJx2aZFzFy1S6eUqNjXsOqTK10zNRff2dNfssgokjkG65OlWNcIlgd3zew==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@types/node": "*" + } + }, + "jest-pnp-resolver": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.2.tgz", + "integrity": "sha512-olV41bKSMm8BdnuMsewT4jqlZ8+3TCARAXjZGT9jcoSnrfUnRCqnMoF9XEeoWjbzObpqF9dRhHQj0Xb9QdF6/w==", + "dev": true + }, + "jest-regex-util": { + "version": "26.0.0", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-26.0.0.tgz", + "integrity": "sha512-Gv3ZIs/nA48/Zvjrl34bf+oD76JHiGDUxNOVgUjh3j890sblXryjY4rss71fPtD/njchl6PSE2hIhvyWa1eT0A==", + "dev": true + }, + "jest-resolve": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-26.6.2.tgz", + "integrity": "sha512-sOxsZOq25mT1wRsfHcbtkInS+Ek7Q8jCHUB0ZUTP0tc/c41QHriU/NunqMfCUWsL4H3MHpvQD4QR9kSYhS7UvQ==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^26.6.2", + "read-pkg-up": "^7.0.1", + "resolve": "^1.18.1", + "slash": "^3.0.0" + }, + "dependencies": { + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "parse-json": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.1.0.tgz", + "integrity": "sha512-+mi/lmVVNKFNVyLXV31ERiy2CY5E1/F6QtJFEzoChPRwwngMNXRDQ9GJ5WdE2Z2P4AujsOi0/+2qHID68KwfIQ==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + } + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "read-pkg": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz", + "integrity": "sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==", + "dev": true, + "requires": { + "@types/normalize-package-data": "^2.4.0", + "normalize-package-data": "^2.5.0", + "parse-json": "^5.0.0", + "type-fest": "^0.6.0" + }, + "dependencies": { + "type-fest": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz", + "integrity": "sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==", + "dev": true + } + } + }, + "read-pkg-up": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz", + "integrity": "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==", + "dev": true, + "requires": { + "find-up": "^4.1.0", + "read-pkg": "^5.2.0", + "type-fest": "^0.8.1" + } + }, + "resolve": { + "version": "1.19.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz", + "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==", + "dev": true, + "requires": { + "is-core-module": "^2.1.0", + "path-parse": "^1.0.6" + } + } + } + }, + "jest-resolve-dependencies": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-26.6.3.tgz", + "integrity": "sha512-pVwUjJkxbhe4RY8QEWzN3vns2kqyuldKpxlxJlzEYfKSvY6/bMvxoFrYYzUO1Gx28yKWN37qyV7rIoIp2h8fTg==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-snapshot": "^26.6.2" + } + }, + "jest-runner": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-26.6.3.tgz", + "integrity": "sha512-atgKpRHnaA2OvByG/HpGA4g6CSPS/1LK0jK3gATJAoptC1ojltpmVlYC3TYgdmGp+GLuhzpH30Gvs36szSL2JQ==", + "dev": true, + "requires": { + "@jest/console": "^26.6.2", + "@jest/environment": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.7.1", + "exit": "^0.1.2", + "graceful-fs": "^4.2.4", + "jest-config": "^26.6.3", + "jest-docblock": "^26.0.0", + "jest-haste-map": "^26.6.2", + "jest-leak-detector": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-resolve": "^26.6.2", + "jest-runtime": "^26.6.3", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", + "source-map-support": "^0.5.6", + "throat": "^5.0.0" + } + }, + "jest-runtime": { + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-26.6.3.tgz", + "integrity": "sha512-lrzyR3N8sacTAMeonbqpnSka1dHNux2uk0qqDXVkMv2c/A3wYnvQ4EXuI013Y6+gSKSCxdaczvf4HF0mVXHRdw==", + "dev": true, + "requires": { + "@jest/console": "^26.6.2", + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/globals": "^26.6.2", + "@jest/source-map": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/yargs": "^15.0.0", + "chalk": "^4.0.0", + "cjs-module-lexer": "^0.6.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.4", + "jest-config": "^26.6.3", + "jest-haste-map": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-mock": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "slash": "^3.0.0", + "strip-bom": "^4.0.0", + "yargs": "^15.4.1" + }, + "dependencies": { + "strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true + } + } + }, + "jest-serializer": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-26.6.2.tgz", + "integrity": "sha512-S5wqyz0DXnNJPd/xfIzZ5Xnp1HrJWBczg8mMfMpN78OJ5eDxXyf+Ygld9wX1DnUWbIbhM1YDY95NjR4CBXkb2g==", + "dev": true, + "requires": { + "@types/node": "*", + "graceful-fs": "^4.2.4" + } + }, + "jest-snapshot": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-26.6.2.tgz", + "integrity": "sha512-OLhxz05EzUtsAmOMzuupt1lHYXCNib0ECyuZ/PZOx9TrZcC8vL0x+DUG3TL+GLX3yHG45e6YGjIm0XwDc3q3og==", + "dev": true, + "requires": { + "@babel/types": "^7.0.0", + "@jest/types": "^26.6.2", + "@types/babel__traverse": "^7.0.4", + "@types/prettier": "^2.0.0", + "chalk": "^4.0.0", + "expect": "^26.6.2", + "graceful-fs": "^4.2.4", + "jest-diff": "^26.6.2", + "jest-get-type": "^26.3.0", + "jest-haste-map": "^26.6.2", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-resolve": "^26.6.2", + "natural-compare": "^1.4.0", + "pretty-format": "^26.6.2", + "semver": "^7.3.2" + } + }, + "jest-util": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-26.6.2.tgz", + "integrity": "sha512-MDW0fKfsn0OI7MS7Euz6h8HNDXVQ0gaM9uW6RjfDmd1DAFcaxX9OqIakHIqhbnmF08Cf2DLDG+ulq8YQQ0Lp0Q==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "is-ci": "^2.0.0", + "micromatch": "^4.0.2" + } + }, + "jest-validate": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-26.6.2.tgz", + "integrity": "sha512-NEYZ9Aeyj0i5rQqbq+tpIOom0YS1u2MVu6+euBsvpgIme+FOfRmoC4R5p0JiAUpaFvFy24xgrpMknarR/93XjQ==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "camelcase": "^6.0.0", + "chalk": "^4.0.0", + "jest-get-type": "^26.3.0", + "leven": "^3.1.0", + "pretty-format": "^26.6.2" + }, + "dependencies": { + "camelcase": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz", + "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==", + "dev": true + } + } + }, + "jest-watcher": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-26.6.2.tgz", + "integrity": "sha512-WKJob0P/Em2csiVthsI68p6aGKTIcsfjH9Gsx1f0A3Italz43e3ho0geSAVsmj09RWOELP1AZ/DXyJgOgDKxXQ==", + "dev": true, + "requires": { + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "jest-util": "^26.6.2", + "string-length": "^4.0.1" + } + }, + "jest-worker": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", + "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "dev": true, + "requires": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^7.0.0" + }, + "dependencies": { + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "jmespath": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/jmespath/-/jmespath-0.15.0.tgz", + "integrity": "sha1-o/Iiqarp+Wb10nx5ZRDigJF2Qhc=" + }, + "js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true + }, + "js-yaml": { + "version": "3.14.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.0.tgz", + "integrity": "sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==", + "dev": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=" + }, + "jsdom": { + "version": "16.4.0", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.4.0.tgz", + "integrity": "sha512-lYMm3wYdgPhrl7pDcRmvzPhhrGVBeVhPIqeHjzeiHN3DFmD1RBpbExbi8vU7BJdH8VAZYovR8DMt0PNNDM7k8w==", + "dev": true, + "requires": { + "abab": "^2.0.3", + "acorn": "^7.1.1", + "acorn-globals": "^6.0.0", + "cssom": "^0.4.4", + "cssstyle": "^2.2.0", + "data-urls": "^2.0.0", + "decimal.js": "^10.2.0", + "domexception": "^2.0.1", + "escodegen": "^1.14.1", + "html-encoding-sniffer": "^2.0.1", + "is-potential-custom-element-name": "^1.0.0", + "nwsapi": "^2.2.0", + "parse5": "5.1.1", + "request": "^2.88.2", + "request-promise-native": "^1.0.8", + "saxes": "^5.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^3.0.1", + "w3c-hr-time": "^1.0.2", + "w3c-xmlserializer": "^2.0.0", + "webidl-conversions": "^6.1.0", + "whatwg-encoding": "^1.0.5", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0", + "ws": "^7.2.3", + "xml-name-validator": "^3.0.0" + }, + "dependencies": { + "tough-cookie": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-3.0.1.tgz", + "integrity": "sha512-yQyJ0u4pZsv9D4clxO69OEjLWYw+jbgspjTue4lTQZLfV0c5l1VmK2y1JK8E9ahdpltPOaAThPcp5nKPUgSnsg==", + "dev": true, + "requires": { + "ip-regex": "^2.1.0", + "psl": "^1.1.28", + "punycode": "^2.1.1" + } + } + } + }, + "jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true + }, + "json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", + "dev": true + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json5": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz", + "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==", + "dev": true, + "requires": { + "minimist": "^1.2.0" + } + }, + "jsonpath-plus": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonpath-plus/-/jsonpath-plus-4.0.0.tgz", + "integrity": "sha512-e0Jtg4KAzDJKKwzbLaUtinCn0RZseWBVRTRGihSpvFlM3wTR7ExSp+PTdeTsDrLNJUe7L7JYJe8mblHX5SCT6A==" + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "dev": true + }, + "kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "dev": true + }, + "leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true + }, + "levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + } + }, + "libsodium": { + "version": "0.7.8", + "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.8.tgz", + "integrity": "sha512-/Qc+APf0jbeWSaeEruH0L1/tbbT+sbf884ZL0/zV/0JXaDPBzYkKbyb/wmxMHgAHzm3t6gqe7bOOXAVwfqVikQ==" + }, + "libsodium-sumo": { + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/libsodium-sumo/-/libsodium-sumo-0.7.6.tgz", + "integrity": "sha512-1XM2w00YkufeLVhFbw9aV+NTftzqECkEU1Amw2MxCbYuyy4L6MH5y8MWOg3shN6X/9R3e1pp6RCSXPnbFRTVCA==" + }, + "libsodium-wrappers": { + "version": "0.7.8", + "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.8.tgz", + "integrity": "sha512-PDhPWXBqd/SaqAFUBgH2Ux7b3VEEJgyD6BQB+VdNFJb9PbExGr/T/myc/MBoSvl8qLzfm0W0IVByOQS5L1MrCg==", + "requires": { + "libsodium": "0.7.8" + } + }, + "libsodium-wrappers-sumo": { + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/libsodium-wrappers-sumo/-/libsodium-wrappers-sumo-0.7.6.tgz", + "integrity": "sha512-pwYQ1ZR/UwXBMY4tFDcjYZrBFgexkhRykzcE9Jv0l/J41Tp7PqHYfHA17YpOxIXrAIRBPVSlPo2VxHoGZZKwXA==", + "requires": { + "libsodium-sumo": "0.7.6" + } + }, + "lines-and-columns": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz", + "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=", + "dev": true + }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "strip-bom": "^3.0.0" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "dev": true, + "requires": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + } + }, + "lodash": { + "version": "4.17.20", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz", + "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==" + }, + "lodash.sortby": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz", + "integrity": "sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=", + "dev": true + }, + "loglevel": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/loglevel/-/loglevel-1.7.0.tgz", + "integrity": "sha512-i2sY04nal5jDcagM3FMfG++T69GEEM8CYuOfeOIvmXzOIcwE9a/CJPR0MFM97pYMj/u10lzz7/zd7+qwhrBTqQ==" + }, + "make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "dev": true, + "requires": { + "semver": "^6.0.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==" + }, + "makeerror": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.11.tgz", + "integrity": "sha1-4BpckQnyr3lmDk6LlYd5AYT1qWw=", + "dev": true, + "requires": { + "tmpl": "1.0.x" + } + }, + "map-cache": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", + "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", + "dev": true + }, + "map-visit": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", + "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", + "dev": true, + "requires": { + "object-visit": "^1.0.0" + } + }, + "md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true + }, + "micromatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz", + "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==", + "dev": true, + "requires": { + "braces": "^3.0.1", + "picomatch": "^2.0.5" + } + }, + "mime-db": { + "version": "1.44.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.44.0.tgz", + "integrity": "sha512-/NOTfLrsPBVeH7YtFPgsVWveuL+4SjjYxaQ1xtM1KMFj7HdxlBlxeyNLzhyJVx7r4rZGJAZ/6lkKCitSc/Nmpg==" + }, + "mime-types": { + "version": "2.1.27", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.27.tgz", + "integrity": "sha512-JIhqnCasI9yD+SsmkquHBxTSEuZdQX5BuQnS2Vc7puQQQ+8yiP5AY5uWhpdv4YL4VM5c6iliiYWPgJ/nJQLp7w==", + "requires": { + "mime-db": "1.44.0" + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, + "mimic-response": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-2.1.0.tgz", + "integrity": "sha512-wXqjST+SLt7R009ySCglWBCFpjUygmCIfD790/kVbiGmUgfYGuB14PiTd5DwVxSV4NcYHjzMkoj5LjQZwTQLEA==" + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==" + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==" + }, + "mixin-deep": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", + "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", + "dev": true, + "requires": { + "for-in": "^1.0.2", + "is-extendable": "^1.0.1" + }, + "dependencies": { + "is-extendable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", + "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", + "dev": true, + "requires": { + "is-plain-object": "^2.0.4" + } + } + } + }, + "mkdirp": { + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz", + "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==", + "requires": { + "minimist": "^1.2.5" + } + }, + "mkdirp-classic": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", + "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==" + }, + "moo": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.0.tgz", + "integrity": "sha512-AMv6iqhTEd5vT/cQlH6cammKS5ekyHhyqTRKi5zKMWl1RTyFnQ3ohPSBNSm8ySe2wlxSKwDonr9D5ZT44mdO3g==" + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "nan": { + "version": "2.14.1", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.1.tgz", + "integrity": "sha512-isWHgVjnFjh2x2yuJ/tj3JbwoHu3UC2dX5G/88Cm24yB6YopVgxvBObDY7n5xW6ExmFhJpSEQqFPvq9zaXc8Jw==" + }, + "nanomatch": { + "version": "1.2.13", + "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", + "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", + "dev": true, + "requires": { + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "fragment-cache": "^0.2.1", + "is-windows": "^1.0.2", + "kind-of": "^6.0.2", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" + } + }, + "napi-build-utils": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-1.0.2.tgz", + "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==" + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", + "dev": true + }, + "nearley": { + "version": "2.19.1", + "resolved": "https://registry.npmjs.org/nearley/-/nearley-2.19.1.tgz", + "integrity": "sha512-xq47GIUGXxU9vQg7g/y1o1xuKnkO7ev4nRWqftmQrLkfnE/FjRqDaGOUakM8XHPn/6pW3bGjU2wgoJyId90rqg==", + "requires": { + "commander": "^2.19.0", + "moo": "^0.5.0", + "railroad-diagrams": "^1.0.0", + "randexp": "0.4.6", + "semver": "^5.4.1" + }, + "dependencies": { + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + } + } + }, + "nice-try": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz", + "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==", + "dev": true + }, + "node-abi": { + "version": "2.19.1", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-2.19.1.tgz", + "integrity": "sha512-HbtmIuByq44yhAzK7b9j/FelKlHYISKQn0mtvcBrU5QBkhoCMp5bu8Hv5AI34DcKfOAcJBcOEMwLlwO62FFu9A==", + "requires": { + "semver": "^5.4.1" + }, + "dependencies": { + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + } + } + }, + "node-addon-api": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz", + "integrity": "sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==" + }, + "node-fetch": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.1.tgz", + "integrity": "sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==" + }, + "node-gyp-build": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.2.3.tgz", + "integrity": "sha512-MN6ZpzmfNCRM+3t57PTJHgHyw/h4OWnZ6mR8P5j/uZtqQr46RRuDE/P+g3n0YR/AiYXeWixZZzaip77gdICfRg==" + }, + "node-hid": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/node-hid/-/node-hid-1.3.0.tgz", + "integrity": "sha512-BA6G4V84kiNd1uAChub/Z/5s/xS3EHBCxotQ0nyYrUG65mXewUDHE1tWOSqA2dp3N+mV0Ffq9wo2AW9t4p/G7g==", + "requires": { + "bindings": "^1.5.0", + "nan": "^2.14.0", + "node-abi": "^2.18.0", + "prebuild-install": "^5.3.4" + } + }, + "node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs=", + "dev": true + }, + "node-modules-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz", + "integrity": "sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=", + "dev": true + }, + "node-notifier": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/node-notifier/-/node-notifier-8.0.0.tgz", + "integrity": "sha512-46z7DUmcjoYdaWyXouuFNNfUo6eFa94t23c53c+lG/9Cvauk4a98rAUp9672X5dxGdQmLpPzTxzu8f/OeEPaFA==", + "dev": true, + "optional": true, + "requires": { + "growly": "^1.3.0", + "is-wsl": "^2.2.0", + "semver": "^7.3.2", + "shellwords": "^0.1.1", + "uuid": "^8.3.0", + "which": "^2.0.2" + }, + "dependencies": { + "uuid": { + "version": "8.3.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.1.tgz", + "integrity": "sha512-FOmRr+FmWEIG8uhZv6C2bTgEVXsHk08kE7mPlrBbEe+c3r9pjceVPgupIfNIhc4yx55H69OXANrUaSuu9eInKg==", + "dev": true, + "optional": true + } + } + }, + "noop-logger": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/noop-logger/-/noop-logger-0.1.1.tgz", + "integrity": "sha1-lKKxYzxPExdVMAfYlm/Q6EG2pMI=" + }, + "normalize-package-data": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", + "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", + "dev": true, + "requires": { + "hosted-git-info": "^2.1.4", + "resolve": "^1.10.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + }, + "dependencies": { + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + } + } + }, + "normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true + }, + "npm-run-path": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", + "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", + "dev": true, + "requires": { + "path-key": "^2.0.0" + }, + "dependencies": { + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "dev": true + } + } + }, + "npmlog": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", + "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", + "requires": { + "are-we-there-yet": "~1.1.2", + "console-control-strings": "~1.1.0", + "gauge": "~2.7.3", + "set-blocking": "~2.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=" + }, + "nwsapi": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.0.tgz", + "integrity": "sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ==", + "dev": true + }, + "oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-copy": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", + "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", + "dev": true, + "requires": { + "copy-descriptor": "^0.1.0", + "define-property": "^0.2.5", + "kind-of": "^3.0.3" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "object-inspect": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.8.0.tgz", + "integrity": "sha512-jLdtEOB112fORuypAyl/50VRVIBIdVQOSUUGQHzJ4xBSbit81zRarz7GThkEFZy1RceYrWYcPcBFPQwHyAc1gA==", + "dev": true + }, + "object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true + }, + "object-visit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", + "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", + "dev": true, + "requires": { + "isobject": "^3.0.0" + } + }, + "object.assign": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", + "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", + "dev": true, + "requires": { + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" + } + }, + "object.pick": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", + "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", + "dev": true, + "requires": { + "isobject": "^3.0.1" + } + }, + "object.values": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.1.tgz", + "integrity": "sha512-WTa54g2K8iu0kmS/us18jEmdv1a4Wi//BZ/DTVYEcH0XhLM5NYdpDHja3gt57VrZLcNAO2WGA+KpWsDBaHt6eA==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.0-next.1", + "function-bind": "^1.1.1", + "has": "^1.0.3" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "optionator": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", + "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", + "dev": true, + "requires": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + } + }, + "p-each-series": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-2.2.0.tgz", + "integrity": "sha512-ycIL2+1V32th+8scbpTvyHNaHe02z0sjgh91XXjAk+ZeXoPN4Z46DVUnzdso0aX4KckKw0FNNFHdjZ2UsZvxiA==", + "dev": true + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", + "dev": true + }, + "p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "dev": true, + "requires": { + "p-try": "^1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "dev": true, + "requires": { + "p-limit": "^1.1.0" + } + }, + "p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", + "dev": true + }, + "parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "requires": { + "callsites": "^3.0.0" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "^1.2.0" + } + }, + "parse5": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-5.1.1.tgz", + "integrity": "sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug==", + "dev": true + }, + "pascalcase": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", + "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", + "dev": true + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", + "dev": true + }, + "path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true + }, + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "dev": true + }, + "path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true + }, + "pbkdf2": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.1.tgz", + "integrity": "sha512-4Ejy1OPxi9f2tt1rRV7Go7zmfDQ+ZectEQz3VGUQhgq62HtIRPDyG/JtnwIxs6x3uNMwo2V7q1fMvKjb+Tnpqg==", + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "picomatch": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz", + "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==", + "dev": true + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pirates": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.1.tgz", + "integrity": "sha512-WuNqLTbMI3tmfef2TKxlQmAiLHKtFhlsCZnPIpuv2Ow0RDVO8lfy1Opf4NUzlMXLjPl+Men7AuVdX6TA+s+uGA==", + "dev": true, + "requires": { + "node-modules-regexp": "^1.0.0" + } + }, + "pkg-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz", + "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", + "dev": true, + "requires": { + "find-up": "^2.1.0" + } + }, + "posix-character-classes": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", + "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", + "dev": true + }, + "prebuild-install": { + "version": "5.3.5", + "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-5.3.5.tgz", + "integrity": "sha512-YmMO7dph9CYKi5IR/BzjOJlRzpxGGVo1EsLSUZ0mt/Mq0HWZIHOKHHcHdT69yG54C9m6i45GpItwRHpk0Py7Uw==", + "requires": { + "detect-libc": "^1.0.3", + "expand-template": "^2.0.3", + "github-from-package": "0.0.0", + "minimist": "^1.2.3", + "mkdirp": "^0.5.1", + "napi-build-utils": "^1.0.1", + "node-abi": "^2.7.0", + "noop-logger": "^0.1.1", + "npmlog": "^4.0.1", + "pump": "^3.0.0", + "rc": "^1.2.7", + "simple-get": "^3.0.3", + "tar-fs": "^2.0.0", + "tunnel-agent": "^0.6.0", + "which-pm-runs": "^1.0.0" + } + }, + "prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true + }, + "prettier": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.1.1.tgz", + "integrity": "sha512-9bY+5ZWCfqj3ghYBLxApy2zf6m+NJo5GzmLTpr9FsApsfjriNnS2dahWReHMi7qNPhhHl9SYHJs2cHZLgexNIw==", + "dev": true + }, + "prettier-linter-helpers": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", + "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", + "dev": true, + "requires": { + "fast-diff": "^1.1.2" + } + }, + "pretty-format": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-26.6.2.tgz", + "integrity": "sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "ansi-regex": "^5.0.0", + "ansi-styles": "^4.0.0", + "react-is": "^17.0.1" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + } + } + }, + "process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==" + }, + "progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true + }, + "prompts": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.0.tgz", + "integrity": "sha512-awZAKrk3vN6CroQukBL+R9051a4R3zCZBlJm/HBfrSZ8iTpYix3VX1vU4mveiLpiwmOJT4wokTF9m6HUk4KqWQ==", + "dev": true, + "requires": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + } + }, + "psl": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz", + "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==" + }, + "pump": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", + "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", + "requires": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "punycode": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==" + }, + "qs": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", + "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=" + }, + "railroad-diagrams": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz", + "integrity": "sha1-635iZ1SN3t+4mcG5Dlc3RVnN234=" + }, + "ramda": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.27.1.tgz", + "integrity": "sha512-PgIdVpn5y5Yns8vqb8FzBUEYn98V3xcPgawAkkgj0YJ0qDsnHCiNmZYfOGMgOvoB0eWFLpYbhxUR3mxfDIMvpw==", + "dev": true + }, + "randexp": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/randexp/-/randexp-0.4.6.tgz", + "integrity": "sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==", + "requires": { + "discontinuous-range": "1.0.0", + "ret": "~0.1.10" + } + }, + "randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "requires": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "dependencies": { + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=" + } + } + }, + "react-is": { + "version": "17.0.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.1.tgz", + "integrity": "sha512-NAnt2iGDXohE5LI7uBnLnqvLQMtzhkiAOLXTmv+qnF9Ky7xAPcX8Up/xWIhxvLVGJvuLiNc4xQLtuqDRzb4fSA==", + "dev": true + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "dev": true, + "requires": { + "load-json-file": "^2.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^2.0.0" + }, + "dependencies": { + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "dev": true, + "requires": { + "pify": "^2.0.0" + } + } + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "dev": true, + "requires": { + "find-up": "^2.0.0", + "read-pkg": "^2.0.0" + } + }, + "readable-stream": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", + "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + }, + "regex-not": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", + "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", + "dev": true, + "requires": { + "extend-shallow": "^3.0.2", + "safe-regex": "^1.1.0" + } + }, + "regexpp": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.1.0.tgz", + "integrity": "sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q==", + "dev": true + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", + "dev": true + }, + "repeat-element": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz", + "integrity": "sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==", + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "request": { + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "requires": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.5.0", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + }, + "dependencies": { + "form-data": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.6", + "mime-types": "^2.1.12" + } + } + } + }, + "request-promise-core": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz", + "integrity": "sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw==", + "dev": true, + "requires": { + "lodash": "^4.17.19" + } + }, + "request-promise-native": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz", + "integrity": "sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g==", + "dev": true, + "requires": { + "request-promise-core": "1.1.4", + "stealthy-require": "^1.1.1", + "tough-cookie": "^2.3.3" + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", + "dev": true + }, + "require-main-filename": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz", + "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==", + "dev": true + }, + "resolve": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz", + "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==", + "dev": true, + "requires": { + "path-parse": "^1.0.6" + } + }, + "resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "requires": { + "resolve-from": "^5.0.0" + }, + "dependencies": { + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + } + } + }, + "resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true + }, + "resolve-url": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", + "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", + "dev": true + }, + "ret": { + "version": "0.1.15", + "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==" + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true + }, + "rimraf": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "rsvp": { + "version": "4.8.5", + "resolved": "https://registry.npmjs.org/rsvp/-/rsvp-4.8.5.tgz", + "integrity": "sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA==", + "dev": true + }, + "run-parallel": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.1.9.tgz", + "integrity": "sha512-DEqnSRTDw/Tc3FXf49zedI638Z9onwUotBMiUFKmrO2sdFKIbXamXGQ3Axd4qgphxKB4kw/qP1w5kTxnfU1B9Q==", + "dev": true + }, + "rxjs": { + "version": "6.6.3", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.3.tgz", + "integrity": "sha512-trsQc+xYYXZ3urjOiJOuCOa5N3jAZ3eiSpQB5hIT8zGlL2QfnHLJ2r7GMkBGuIausdJN1OneaI6gQlsqNHHmZQ==", + "requires": { + "tslib": "^1.9.0" + } + }, + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==" + }, + "safe-regex": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", + "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", + "dev": true, + "requires": { + "ret": "~0.1.10" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "sane": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/sane/-/sane-4.1.0.tgz", + "integrity": "sha512-hhbzAgTIX8O7SHfp2c8/kREfEn4qO/9q8C9beyY6+tvZ87EpoZ3i1RIEvp27YBswnNbY9mWd6paKVmKbAgLfZA==", + "dev": true, + "requires": { + "@cnakazawa/watch": "^1.0.3", + "anymatch": "^2.0.0", + "capture-exit": "^2.0.0", + "exec-sh": "^0.3.2", + "execa": "^1.0.0", + "fb-watchman": "^2.0.0", + "micromatch": "^3.1.4", + "minimist": "^1.1.1", + "walker": "~1.0.5" + }, + "dependencies": { + "anymatch": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", + "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", + "dev": true, + "requires": { + "micromatch": "^3.1.4", + "normalize-path": "^2.1.1" + } + }, + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "^1.1.0", + "array-unique": "^0.3.2", + "extend-shallow": "^2.0.1", + "fill-range": "^4.0.0", + "isobject": "^3.0.1", + "repeat-element": "^1.1.2", + "snapdragon": "^0.8.1", + "snapdragon-node": "^2.0.1", + "split-string": "^3.0.2", + "to-regex": "^3.0.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-number": "^3.0.0", + "repeat-string": "^1.6.1", + "to-regex-range": "^2.1.0" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "micromatch": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "dev": true, + "requires": { + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "braces": "^2.3.1", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "extglob": "^2.0.4", + "fragment-cache": "^0.2.1", + "kind-of": "^6.0.2", + "nanomatch": "^1.2.9", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.2" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "^1.0.1" + } + }, + "to-regex-range": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "repeat-string": "^1.6.1" + } + } + } + }, + "sax": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.1.tgz", + "integrity": "sha1-e45lYZCyKOgaZq6nSEgNgozS03o=" + }, + "saxes": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz", + "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==", + "dev": true, + "requires": { + "xmlchars": "^2.2.0" + } + }, + "secp256k1": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.2.tgz", + "integrity": "sha512-UDar4sKvWAksIlfX3xIaQReADn+WFnHvbVujpcbr+9Sf/69odMwy2MUsz5CKLQgX9nsIyrjuxL2imVyoNHa3fg==", + "requires": { + "elliptic": "^6.5.2", + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0" + } + }, + "semver": { + "version": "7.3.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.2.tgz", + "integrity": "sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ==", + "dev": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + }, + "set-value": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", + "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-extendable": "^0.1.1", + "is-plain-object": "^2.0.3", + "split-string": "^3.0.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true + }, + "shellwords": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/shellwords/-/shellwords-0.1.1.tgz", + "integrity": "sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==", + "dev": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz", + "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==" + }, + "simple-concat": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", + "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==" + }, + "simple-get": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.0.tgz", + "integrity": "sha512-bCR6cP+aTdScaQCnQKbPKtJOKDp/hj9EDLJo3Nw4y1QksqaovlW/bnptB6/c1e+qmNIDHRK+oXFDdEqBT8WzUA==", + "requires": { + "decompress-response": "^4.2.0", + "once": "^1.3.1", + "simple-concat": "^1.0.0" + } + }, + "sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "dev": true + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true + }, + "slice-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz", + "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.0", + "astral-regex": "^1.0.0", + "is-fullwidth-code-point": "^2.0.0" + } + }, + "snapdragon": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", + "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", + "dev": true, + "requires": { + "base": "^0.11.1", + "debug": "^2.2.0", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "map-cache": "^0.2.2", + "source-map": "^0.5.6", + "source-map-resolve": "^0.5.0", + "use": "^3.1.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "snapdragon-node": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", + "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", + "dev": true, + "requires": { + "define-property": "^1.0.0", + "isobject": "^3.0.0", + "snapdragon-util": "^3.0.1" + }, + "dependencies": { + "define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", + "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "dev": true, + "requires": { + "is-descriptor": "^1.0.0" + } + }, + "is-accessor-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", + "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-data-descriptor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", + "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", + "dev": true, + "requires": { + "kind-of": "^6.0.0" + } + }, + "is-descriptor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", + "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", + "dev": true, + "requires": { + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" + } + } + } + }, + "snapdragon-util": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", + "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", + "dev": true, + "requires": { + "kind-of": "^3.2.0" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "source-map-resolve": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz", + "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==", + "dev": true, + "requires": { + "atob": "^2.1.2", + "decode-uri-component": "^0.2.0", + "resolve-url": "^0.2.1", + "source-map-url": "^0.4.0", + "urix": "^0.1.0" + } + }, + "source-map-support": { + "version": "0.5.19", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz", + "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==", + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "source-map-url": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz", + "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", + "dev": true + }, + "spdx-correct": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", + "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", + "dev": true, + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", + "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", + "dev": true + }, + "spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "dev": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz", + "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==", + "dev": true + }, + "split-string": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", + "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", + "dev": true, + "requires": { + "extend-shallow": "^3.0.0" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, + "sshpk": { + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz", + "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==", + "requires": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + } + }, + "stack-utils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.3.tgz", + "integrity": "sha512-gL//fkxfWUsIlFL2Tl42Cl6+HFALEaB1FU76I/Fy+oZjRreP7OPMXFlGbxM7NQsI0ZpUfw76sHnv0WNYuTb7Iw==", + "dev": true, + "requires": { + "escape-string-regexp": "^2.0.0" + }, + "dependencies": { + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true + } + } + }, + "static-extend": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", + "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", + "dev": true, + "requires": { + "define-property": "^0.2.5", + "object-copy": "^0.1.0" + }, + "dependencies": { + "define-property": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", + "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "dev": true, + "requires": { + "is-descriptor": "^0.1.0" + } + } + } + }, + "stealthy-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz", + "integrity": "sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks=", + "dev": true + }, + "string-length": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.1.tgz", + "integrity": "sha512-PKyXUd0LK0ePjSOnWn34V2uD6acUWev9uy0Ft05k0E8xRW+SKcA0F7eMr7h5xlzfn+4O3N+55rduYyet3Jk+jw==", + "dev": true, + "requires": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + } + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + }, + "dependencies": { + "ansi-regex": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", + "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "dev": true + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "requires": { + "ansi-regex": "^4.1.0" + } + } + } + }, + "string.prototype.trimend": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.1.tgz", + "integrity": "sha512-LRPxFUaTtpqYsTeNKaFOw3R4bxIzWOnbQ837QfBylo8jIxtcbK/A/sMV7Q+OAV/vWo+7s25pOE10KYSjaSO06g==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.5" + } + }, + "string.prototype.trimstart": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.1.tgz", + "integrity": "sha512-XxZn+QpvrBI1FOcg6dIpxUPgWCPuNXvMD72aaRaUQv1eD4e/Qy8i/hFTe0BUmD60p/QA6bh1avmuPTfNjqVWRw==", + "dev": true, + "requires": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.5" + } + }, + "string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "requires": { + "safe-buffer": "~5.2.0" + } + }, + "strip-ansi": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.0" + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "dev": true + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", + "dev": true + }, + "strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true + }, + "strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + }, + "supports-hyperlinks": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.1.0.tgz", + "integrity": "sha512-zoE5/e+dnEijk6ASB6/qrK+oYdm2do1hjoLWrqUC/8WEIW1gbxFcKuBof7sW8ArN6e+AYvsE8HBGiVRWL/F5CA==", + "dev": true, + "requires": { + "has-flag": "^4.0.0", + "supports-color": "^7.0.0" + }, + "dependencies": { + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "symbol-tree": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", + "dev": true + }, + "table": { + "version": "5.4.6", + "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz", + "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==", + "dev": true, + "requires": { + "ajv": "^6.10.2", + "lodash": "^4.17.14", + "slice-ansi": "^2.1.0", + "string-width": "^3.0.0" + } + }, + "tar-fs": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.0.tgz", + "integrity": "sha512-9uW5iDvrIMCVpvasdFHW0wJPez0K4JnMZtsuIeDI7HyMGJNxmDZDOCQROr7lXyS+iL/QMpj07qcjGYTSdRFXUg==", + "requires": { + "chownr": "^1.1.1", + "mkdirp-classic": "^0.5.2", + "pump": "^3.0.0", + "tar-stream": "^2.0.0" + } + }, + "tar-stream": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.1.3.tgz", + "integrity": "sha512-Z9yri56Dih8IaK8gncVPx4Wqt86NDmQTSh49XLZgjWpGZL9GK9HKParS2scqHCC4w6X9Gh2jwaU45V47XTKwVA==", + "requires": { + "bl": "^4.0.1", + "end-of-stream": "^1.4.1", + "fs-constants": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^3.1.1" + } + }, + "terminal-link": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-2.1.1.tgz", + "integrity": "sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==", + "dev": true, + "requires": { + "ansi-escapes": "^4.2.1", + "supports-hyperlinks": "^2.0.0" + } + }, + "test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "requires": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + } + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", + "dev": true + }, + "throat": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/throat/-/throat-5.0.0.tgz", + "integrity": "sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA==", + "dev": true + }, + "tmpl": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.4.tgz", + "integrity": "sha1-I2QN17QtAEM5ERQIIOXPRA5SHdE=", + "dev": true + }, + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=", + "dev": true + }, + "to-object-path": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", + "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "to-regex": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", + "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", + "dev": true, + "requires": { + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "regex-not": "^1.0.2", + "safe-regex": "^1.1.0" + } + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "requires": { + "is-number": "^7.0.0" + } + }, + "tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "requires": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + } + }, + "tr46": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.0.2.tgz", + "integrity": "sha512-3n1qG+/5kg+jrbTzwAykB5yRYtQCTqOGKq5U5PE3b0a1/mzo6snDhjGS0zJVJunO0NrT3Dg1MLy5TjWP/UJppg==", + "dev": true, + "requires": { + "punycode": "^2.1.1" + } + }, + "ts-node": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-9.0.0.tgz", + "integrity": "sha512-/TqB4SnererCDR/vb4S/QvSZvzQMJN8daAslg7MeaiHvD8rDZsSfXmNeNumyZZzMned72Xoq/isQljYSt8Ynfg==", + "dev": true, + "requires": { + "arg": "^4.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "source-map-support": "^0.5.17", + "yn": "3.1.1" + } + }, + "tsconfig-paths": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.9.0.tgz", + "integrity": "sha512-dRcuzokWhajtZWkQsDVKbWyY+jgcLC5sqJhg2PSgf4ZkH2aHPvaOY8YWGhmjb68b5qqTfasSsDO9k7RUiEmZAw==", + "dev": true, + "requires": { + "@types/json5": "^0.0.29", + "json5": "^1.0.1", + "minimist": "^1.2.0", + "strip-bom": "^3.0.0" + } + }, + "tslib": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.13.0.tgz", + "integrity": "sha512-i/6DQjL8Xf3be4K/E6Wgpekn5Qasl1usyw++dAA35Ue5orEn65VIxOA+YvNNl9HV3qv70T7CNwjODHZrLwvd1Q==" + }, + "tsutils": { + "version": "3.17.1", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.17.1.tgz", + "integrity": "sha512-kzeQ5B8H3w60nFY2g8cJIuH7JDpsALXySGtwGJ0p2LSjLgay3NdIpqq5SoOBe46bKDW2iq25irHCr8wjomUS2g==", + "dev": true, + "requires": { + "tslib": "^1.8.1" + } + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=" + }, + "type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true + }, + "type-fest": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz", + "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==", + "dev": true + }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "dev": true, + "requires": { + "is-typedarray": "^1.0.0" + } + }, + "typescript": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.0.3.tgz", + "integrity": "sha512-tEu6DGxGgRJPb/mVPIZ48e69xCn2yRmCgYmDugAVwmJ6o+0u1RI18eO7E7WBTLYLaEVVOhwQmcdhQHweux/WPg==", + "dev": true + }, + "union-value": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", + "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", + "dev": true, + "requires": { + "arr-union": "^3.1.0", + "get-value": "^2.0.6", + "is-extendable": "^0.1.1", + "set-value": "^2.0.1" + } + }, + "unset-value": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", + "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", + "dev": true, + "requires": { + "has-value": "^0.3.1", + "isobject": "^3.0.0" + }, + "dependencies": { + "has-value": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", + "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", + "dev": true, + "requires": { + "get-value": "^2.0.3", + "has-values": "^0.1.4", + "isobject": "^2.0.0" + }, + "dependencies": { + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "requires": { + "isarray": "1.0.0" + } + } + } + }, + "has-values": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", + "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", + "dev": true + } + } + }, + "uri-js": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.0.tgz", + "integrity": "sha512-B0yRTzYdUCCn9n+F4+Gh4yIDtMQcaJsmYBDsTSG8g/OejKBodLQ2IHfN3bM7jUsRXndopT7OIXWdYqc1fjmV6g==", + "requires": { + "punycode": "^2.1.0" + } + }, + "urix": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", + "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", + "dev": true + }, + "url": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/url/-/url-0.10.3.tgz", + "integrity": "sha1-Ah5NnHcF8hu/N9A861h2dAJ3TGQ=", + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=" + } + } + }, + "usb": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/usb/-/usb-1.6.3.tgz", + "integrity": "sha512-23KYMjaWydACd8wgGKMQ4MNwFspAT6Xeim4/9Onqe5Rz/nMb4TM/WHL+qPT0KNFxzNKzAs63n1xQWGEtgaQ2uw==", + "requires": { + "bindings": "^1.4.0", + "nan": "2.13.2", + "prebuild-install": "^5.3.3" + }, + "dependencies": { + "nan": { + "version": "2.13.2", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.13.2.tgz", + "integrity": "sha512-TghvYc72wlMGMVMluVo9WRJc0mB8KxxF/gZ4YYFy7V2ZQX9l7rgbPg7vjS9mt6U5HXODVFVI2bOduCzwOMv/lw==" + } + } + }, + "use": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", + "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", + "dev": true + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "uuid": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", + "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==" + }, + "v8-compile-cache": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.1.1.tgz", + "integrity": "sha512-8OQ9CL+VWyt3JStj7HX7/ciTL2V3Rl1Wf5OL+SNTm0yK1KvtReVulksyeRnCANHHuUxHlQig+JJDlUhBt1NQDQ==", + "dev": true + }, + "v8-to-istanbul": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-7.0.0.tgz", + "integrity": "sha512-fLL2rFuQpMtm9r8hrAV2apXX/WqHJ6+IC4/eQVdMDGBUgH/YMV4Gv3duk3kjmyg6uiQWBAA9nJwue4iJUOkHeA==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0", + "source-map": "^0.7.3" + }, + "dependencies": { + "source-map": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz", + "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==", + "dev": true + } + } + }, + "validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "requires": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "w3c-hr-time": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz", + "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==", + "dev": true, + "requires": { + "browser-process-hrtime": "^1.0.0" + } + }, + "w3c-xmlserializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz", + "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==", + "dev": true, + "requires": { + "xml-name-validator": "^3.0.0" + } + }, + "walker": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.7.tgz", + "integrity": "sha1-L3+bj9ENZ3JisYqITijRlhjgKPs=", + "dev": true, + "requires": { + "makeerror": "1.0.x" + } + }, + "web-request": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/web-request/-/web-request-1.0.7.tgz", + "integrity": "sha1-twxCs81FV3noLbaIYlOySR8r1Wk=", + "requires": { + "request": "^2.69.0" + } + }, + "webidl-conversions": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz", + "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==", + "dev": true + }, + "whatwg-encoding": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz", + "integrity": "sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw==", + "dev": true, + "requires": { + "iconv-lite": "0.4.24" + } + }, + "whatwg-mimetype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz", + "integrity": "sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g==", + "dev": true + }, + "whatwg-url": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.4.0.tgz", + "integrity": "sha512-vwTUFf6V4zhcPkWp/4CQPr1TW9Ml6SF4lVyaIMBdJw5i6qUUJ1QWM4Z6YYVkfka0OUIzVo/0aNtGVGk256IKWw==", + "dev": true, + "requires": { + "lodash.sortby": "^4.7.0", + "tr46": "^2.0.2", + "webidl-conversions": "^6.1.0" + } + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "which-module": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", + "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=", + "dev": true + }, + "which-pm-runs": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/which-pm-runs/-/which-pm-runs-1.0.0.tgz", + "integrity": "sha1-Zws6+8VS4LVd9rd4DKdGFfI60cs=" + }, + "wide-align": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", + "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", + "requires": { + "string-width": "^1.0.2 || 2" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "requires": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "requires": { + "ansi-regex": "^3.0.0" + } + } + } + }, + "word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "dev": true + }, + "wrap-ansi": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", + "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==", + "dev": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "string-width": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/write/-/write-1.0.3.tgz", + "integrity": "sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig==", + "dev": true, + "requires": { + "mkdirp": "^0.5.1" + } + }, + "write-file-atomic": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", + "dev": true, + "requires": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "ws": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.1.tgz", + "integrity": "sha512-pTsP8UAfhy3sk1lSk/O/s4tjD0CRwvMnzvwr4OKGX7ZvqZtUyx4KIJB5JWbkykPoc55tixMGgTNoh3k4FkNGFQ==", + "dev": true + }, + "xml-name-validator": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz", + "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==", + "dev": true + }, + "xml2js": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.19.tgz", + "integrity": "sha512-esZnJZJOiJR9wWKMyuvSE1y6Dq5LCuJanqhxslH2bxM6duahNZ+HMpCLhBQGZkbX6xRf8x1Y2eJlgt2q3qo49Q==", + "requires": { + "sax": ">=0.6.0", + "xmlbuilder": "~9.0.1" + } + }, + "xmlbuilder": { + "version": "9.0.7", + "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz", + "integrity": "sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=" + }, + "xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", + "dev": true + }, + "y18n": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.1.tgz", + "integrity": "sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==", + "dev": true + }, + "yargs": { + "version": "15.4.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz", + "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==", + "dev": true, + "requires": { + "cliui": "^6.0.0", + "decamelize": "^1.2.0", + "find-up": "^4.1.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^4.2.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^18.1.2" + }, + "dependencies": { + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "string-width": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + } + } + }, + "yargs-parser": { + "version": "18.1.3", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz", + "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==", + "dev": true, + "requires": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==" + } + } +} diff --git a/deploy/package.json b/deploy/package.json new file mode 100644 index 00000000..cfed3d35 --- /dev/null +++ b/deploy/package.json @@ -0,0 +1,52 @@ +{ + "name": "kolibri-deploy", + "version": "1.0.0", + "description": "Deploys contracts for Kolibri.", + "main": "index.ts", + "scripts": { + "build-smart-contracts": "cd ../smart_contracts && ./compile.sh && cd ../deploy/", + "build": "npx tsc -d", + "deploy": "npm run build-smart-contracts && npm run deploy-no-build", + "deploy-no-build": "npx ts-node src/deploy-contracts.ts", + "lint": "npx eslint . --ext .ts --fix", + "test": "echo \"no tests :(\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/hover-labs/kolibri.git" + }, + "keywords": [ + "tezos" + ], + "author": "Hover Labs", + "license": "MIT", + "bugs": { + "url": "https://github.com/hover-labs/kolibri/issues" + }, + "homepage": "https://github.com/hover-labs/kolibri#readme", + "devDependencies": { + "@typescript-eslint/eslint-plugin": "^4.9.0", + "@typescript-eslint/parser": "^4.0.1", + "eslint": "^7.8.1", + "eslint-config-prettier": "^6.11.0", + "eslint-plugin-import": "^2.22.0", + "eslint-plugin-jest": "^24.1.3", + "eslint-plugin-mocha": "^8.0.0", + "eslint-plugin-prettier": "^3.1.4", + "jest": "^26.6.3", + "prettier": "^2.1.1", + "ts-node": "^9.0.0", + "typescript": "^4.0.2" + }, + "dependencies": { + "@tacoinfra/harbinger-lib": "^1.5.0", + "@types/libsodium-wrappers": "^0.7.7", + "@types/node-fetch": "^2.5.7", + "bs58check": "^2.1.2", + "conseiljs": "5.0.5-beta.5", + "conseiljs-softsigner": "^5.0.3", + "libsodium-wrappers": "^0.7.8", + "loglevel": "^1.7.0", + "node-fetch": "^2.6.1" + } +} diff --git a/deploy/src/deploy-contracts.ts b/deploy/src/deploy-contracts.ts new file mode 100644 index 00000000..0fb713c7 --- /dev/null +++ b/deploy/src/deploy-contracts.ts @@ -0,0 +1,457 @@ +import { + initConseil, + loadContract, + deployContract, + sendOperation, +} from './utils' +import { initOracleLib, Utils } from '@tacoinfra/harbinger-lib' +import { TezosNodeReader } from 'conseiljs' + +// How long to wait after an operation broadcast to move on. +// Blocks on mainnet are 60s, blocks on testnet are 30s. Prefer at least 2 blocks in case of a priority 1 bake. +export const OPERATION_DELAY_SECS = 10 + +//------------------------------------------------------------------- +// DEPLOYMENT PARAMETERS +//------------------------------------------------------------------- + +// Whether to use testnet or or mainnet configurations. +const IS_MAINNET = false + +// Tezos node address. +const NODE_ADDRESS = IS_MAINNET + ? 'https://rpc.tzbeta.net' + : 'https://rpczero.tzbeta.net' + +// Initial collateralization ratio. Specified in 6 digits. Ex. 2_000_000 = 2 XTZ / USD for each kUSD. +const COLLATERALIZATION_RATIO = '200000000000000000000' // 200% + +// Harbinger Normalizer Contract to call on. +const HARBINGER_NORMALIZER = IS_MAINNET + ? 'KT1AdbYiPYb5hDuEuVrfxmFehtnBCXv4Np7r' + : 'KT1SUP27JhX24Kvr11oUdWswk7FnCW78ZyUn' + +// Key which will deploy the contracts. +const DEPLOYER_PRIVATE_KEY = + 'edsk3aeocSRnxdWVFm3ShaALUeCTy4PgL6JdeGvzbLjX5jn8D9ZXw5' + +// Log level to use for Conseil. +const CONSEIL_LOG_LEVEL = 'error' // Valid options: 'error' | 'debug' + +// Initial debt ceiling. +const DEBT_CEILING = '1000' // $1000 + +// The maximum delay for data from Harbinger, in seconds. +const MAX_DATA_DELAY_SECS = 30 * 60 // 30 min + +// The liquidation fee. +const LIQUIDATION_FEE = '80000000000000000' // 8% + +// The maximum value allowed in an oven. +// Valid Values: `Some or `None` +const INITIAL_OVEN_MAX_MUTEZ = 'Some 100000000' // 100 XTZ + +// The percent of fees to give to the Dev fund +const DEV_FUND_SPLIT = '100000000000000000' // 10% + +// The stability fee to apply per period. +const STABILITY_FEE = 0 // 0% + +// Initial oven baker. +// Valid values: `Some ` or `None` +const INITIAL_OVEN_BAKER = 'None' + +//------------------------------------------------------------------- +// PROGRAM +//------------------------------------------------------------------- + +const currentDate = new Date() +const timestampMs = currentDate.getTime() +const timestampSec = Math.floor(timestampMs / 1000) + +async function main() { + console.log('------------------------------------------------------') + console.log('> Deploying Kolibri Infrastructure') + console.log('>> Running Pre Flight Checks...') + console.log('------------------------------------------------------') + + console.log('>>> [1/5] Input params:') + console.log(`Tezos Node: ${NODE_ADDRESS}`) + console.log(`Initial Collateralization Ratio: ${COLLATERALIZATION_RATIO}`) + console.log(`Initial time: ${timestampSec}`) + console.log('') + + console.log( + `>>> [2/5] Initializing Conseil with logging level: ${CONSEIL_LOG_LEVEL}`, + ) + initConseil(CONSEIL_LOG_LEVEL) + initOracleLib(CONSEIL_LOG_LEVEL) + console.log('Conseil initialized.') + console.log('') + + console.log('>>> [3/5] Initializing Deployer') + const keystore = await Utils.keyStoreFromPrivateKey(DEPLOYER_PRIVATE_KEY) + await Utils.revealAccountIfNeeded( + NODE_ADDRESS, + keystore, + await Utils.signerFromKeyStore(keystore), + ) + console.log(`Initialized deployer: ${keystore.publicKeyHash}`) + console.log('') + + console.log('>>> [4/5] Loading contracts...') + const tokenContractSource = loadContract( + `${__dirname}/../../smart_contracts/token.tz`, + ) + const minterContractSource = loadContract( + `${__dirname}/../../smart_contracts/minter.tz`, + ) + const ovenProxyContractSource = loadContract( + `${__dirname}/../../smart_contracts/oven-proxy.tz`, + ) + const ovenRegistryContractSource = loadContract( + `${__dirname}/../../smart_contracts/oven-registry.tz`, + ) + const ovenFactoryContractSource = loadContract( + `${__dirname}/../../smart_contracts/oven-factory.tz`, + ) + const devFundContractSource = loadContract( + `${__dirname}/../../smart_contracts/dev-fund.tz`, + ) + const stabilityFundContractSource = loadContract( + `${__dirname}/../../smart_contracts/stability-fund.tz`, + ) + const oracleSource = loadContract( + `${__dirname}/../../smart_contracts/oracle.tz`, + ) + console.log('Contracts loaded.') + console.log('') + + console.log('>>> [5/5] Getting Account Counter') + let counter = await TezosNodeReader.getCounterForAccount( + NODE_ADDRESS, + keystore.publicKeyHash, + ) + console.log(`Got counter: ${counter}`) + console.log('') + + console.log('------------------------------------------------------') + console.log('>> Preflight Checks Passed!') + console.log('>> Deploying Contracts...') + console.log('------------------------------------------------------') + console.log('') + + console.log('>>> [1/9] Deploying Minter Contract...') + // Constants: + // Interest Index: 1000000000000000000 (1) + const minterContractStorage = `(Pair (Pair (Pair ${COLLATERALIZATION_RATIO} (Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}")) (Pair 1000000000000000000 (Pair "${timestampSec}" ${LIQUIDATION_FEE}))) (Pair (Pair (${INITIAL_OVEN_MAX_MUTEZ}) (Pair "${keystore.publicKeyHash}" ${DEV_FUND_SPLIT})) (Pair ${STABILITY_FEE} (Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}"))))` + counter++ + const minterContractDeployResult = await deployContract( + minterContractSource, + minterContractStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [2/9] Deploying Oven Proxy Contract...') + // Constants: + // state: 0 (IDLE) + const ovenProxyStorage = `(Pair (Pair (Pair None "${keystore.publicKeyHash}") (Pair None (Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}"))) (Pair (Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}") (Pair False (Pair 0 None))))` + counter++ + const ovenProxyDeployResult = await deployContract( + ovenProxyContractSource, + ovenProxyStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [3/9] Deploying Oven Factory Contract...') + // Constants: + // makeOvenOwner: None + // state: 0 (IDLE) + const ovenFactoryStorage = `(Pair (Pair "${keystore.publicKeyHash}" (Pair (${INITIAL_OVEN_BAKER}) None)) (Pair (Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}") (Pair "${keystore.publicKeyHash}" 0)))` + counter++ + const ovenFactoryDeployResult = await deployContract( + ovenFactoryContractSource, + ovenFactoryStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [4/9] Deploying Token Contract...') + // Constants: + // Balances: {} (No initial balances) + // Metadata: {} (No initial metadata) + // Paused: False + const tokenContractStorage = `(Pair (Pair (Pair "${keystore.publicKeyHash}" {}) (Pair ${DEBT_CEILING} "${keystore.publicKeyHash}")) (Pair (Pair {Elt "" 0x74657a6f732d73746f726167653a64617461; Elt "data" 0x7b20226e616d65223a20224b6f6c6962726920546f6b656e20436f6e7472616374222c20226465736372697074696f6e223a20224641312e3220496d706c656d656e746174696f6e206f66206b555344222c2022617574686f72223a2022486f766572204c616273222c2022686f6d6570616765223a20202268747470733a2f2f6b6f6c696272692e66696e616e6365222c2022696e7465726661636573223a205b2022545a49502d3030372d323032312d30312d3239225d207d} False) (Pair {Elt 0 (Pair 0 {Elt "decimals" 0x3138; Elt "icon" 0x2068747470733a2f2f6b6f6c696272692d646174612e73332e616d617a6f6e6177732e636f6d2f6c6f676f2e706e67; Elt "name" 0x4b6f6c6962726920555344; Elt "symbol" 0x6b555344})} 0)))` + counter++ + const tokenContractDeployResult = await deployContract( + tokenContractSource, + tokenContractStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [5/9] Deploying Oven Registry Contract...') + // Constants: + // OvenMap: {} (No initial ovens) + const ovenRegistryStorage = `(Pair "${keystore.publicKeyHash}"(Pair "${keystore.publicKeyHash}" {}))` + counter++ + const ovenRegistryDeployResult = await deployContract( + ovenRegistryContractSource, + ovenRegistryStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [6/9] Deploying Dev Fund Contract...') + const devFundStorage = `(Pair "${keystore.publicKeyHash}"(Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}"))` + counter++ + const devFundDeployResult = await deployContract( + devFundContractSource, + devFundStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [7/9] Deploying Stability Fund Contract...') + const stabilityFundStorage = `(Pair(Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}")(Pair "${keystore.publicKeyHash}" "${keystore.publicKeyHash}"))` + counter++ + const stabilityFundDeployResult = await deployContract( + stabilityFundContractSource, + stabilityFundStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [8/9] Deploying Oracle Contract...') + // Constants: + // clientCallback: None + // state: 0 (IDLE) + const oracleStorage = `(Pair(Pair None "${keystore.publicKeyHash}")(Pair "${HARBINGER_NORMALIZER}"(Pair ${MAX_DATA_DELAY_SECS} 0)))` + counter++ + const oracleDeployResult = await deployContract( + oracleSource, + oracleStorage, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Deployed.') + console.log('') + + console.log('>>> [9/9] Finishing up...') + console.log( + `Waiting ${OPERATION_DELAY_SECS} seconds for operations to settle in blocks...`, + ) + await Utils.sleep(OPERATION_DELAY_SECS) + console.log('Onwards!') + console.log('') + + console.log('------------------------------------------------------') + console.log('>> Contracts Deployed!') + console.log('>> Wiring contracts to each other...') + console.log('------------------------------------------------------') + console.log('') + + // Oven Proxy + console.log('>>> [1/11] Setting Oven Proxy to point to minter.') + counter++ + await sendOperation( + ovenProxyDeployResult.contractAddress, + 'setMinterContract', + `"${minterContractDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + + console.log('Done.') + console.log('') + + console.log('>>> [2/11] Setting Oven Proxy to point to oven registry.') + counter++ + await sendOperation( + ovenProxyDeployResult.contractAddress, + 'setOvenRegistryContract', + `"${ovenRegistryDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + console.log('>>> [3/11] Setting Oven Proxy to point to oven registry.') + counter++ + await sendOperation( + ovenProxyDeployResult.contractAddress, + 'setOracleContract', + `"${oracleDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + // Minter + console.log('>>> [4/11] Setting Minter to use Contracts') + counter++ + const minterParam = `(Pair "${keystore.publicKeyHash}"(Pair "${tokenContractDeployResult.contractAddress}"(Pair "${ovenProxyDeployResult.contractAddress}"(Pair "${stabilityFundDeployResult.contractAddress}" "${devFundDeployResult.contractAddress}"))))` + console.log(`Minter param: ${minterParam} `) + await sendOperation( + minterContractDeployResult.contractAddress, + 'updateContracts', + minterParam, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + // Token Contract + console.log('>>> [5/11] Setting Token Contract to use Minter as Admin') + counter++ + await sendOperation( + tokenContractDeployResult.contractAddress, + 'setAdministrator', + `"${minterContractDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + // Oven Factory + console.log('>>> [6/11] Setting Oven Factory Contract to use Oven Registry') + counter++ + await sendOperation( + ovenFactoryDeployResult.contractAddress, + 'setOvenRegistryContract', + `"${ovenRegistryDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + console.log('>>> [7/11] Setting Oven Factory Contract to use Minter') + counter++ + await sendOperation( + ovenFactoryDeployResult.contractAddress, + 'setMinterContract', + `"${minterContractDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + console.log('>>> [8/11] Setting Oven Factory Contract to use Oven Proxy') + counter++ + await sendOperation( + ovenFactoryDeployResult.contractAddress, + 'setOvenProxyContract', + `"${ovenProxyDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + // Oven Registry + console.log('>>> [9/11] Setting Oven Registry Contract to use Oven Factory') + counter++ + await sendOperation( + ovenRegistryDeployResult.contractAddress, + 'setOvenFactoryContract', + `"${ovenFactoryDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + // Stability Fund + console.log('>>> [10/11] Setting Stability Fund to use Oven Registry') + counter++ + await sendOperation( + stabilityFundDeployResult.contractAddress, + 'setOvenRegistryContract', + `"${ovenRegistryDeployResult.contractAddress}"`, + keystore, + counter, + NODE_ADDRESS, + ) + console.log('Done.') + console.log('') + + console.log('>>> [11/11] Finishing up...') + console.log( + `Waiting ${OPERATION_DELAY_SECS} seconds for operations to settle in blocks...`, + ) + await Utils.sleep(OPERATION_DELAY_SECS) + console.log('Onwards!') + console.log('') + + console.log('------------------------------------------------------') + console.log('>> Multisig Setup Done!') + console.log('> All Done!') + console.log('------------------------------------------------------') + console.log('') + + console.log( + `Minter Contract: ${minterContractDeployResult.contractAddress} / ${minterContractDeployResult.operationHash}`, + ) + console.log( + `Oven Proxy Contract: ${ovenProxyDeployResult.contractAddress} / ${ovenProxyDeployResult.operationHash}`, + ) + console.log( + `Oven Factory Contract: ${ovenFactoryDeployResult.contractAddress} / ${ovenFactoryDeployResult.operationHash}`, + ) + console.log( + `Token Contract: ${tokenContractDeployResult.contractAddress} / ${tokenContractDeployResult.operationHash}`, + ) + console.log( + `Oven Registry Contract: ${ovenRegistryDeployResult.contractAddress} / ${ovenRegistryDeployResult.operationHash}`, + ) + console.log( + `Dev Fund Contract: ${devFundDeployResult.contractAddress} / ${devFundDeployResult.operationHash}`, + ) + console.log( + `Stability Fund Contract: ${stabilityFundDeployResult.contractAddress} / ${stabilityFundDeployResult.operationHash}`, + ) + console.log( + `Oracle Contract: ${oracleDeployResult.contractAddress} / ${oracleDeployResult.operationHash}`, + ) +} + +void main() diff --git a/deploy/src/utils.ts b/deploy/src/utils.ts new file mode 100644 index 00000000..00157e77 --- /dev/null +++ b/deploy/src/utils.ts @@ -0,0 +1,185 @@ +import fetch from 'node-fetch' +import { getLogger, LogLevelDesc } from 'loglevel' +import { + KeyStore, + registerFetch, + registerLogger, + TezosNodeWriter, + TezosParameterFormat, +} from 'conseiljs' +import fs = require('fs') +import { + Constants, + OperationFeeEstimator, + Utils, +} from '@tacoinfra/harbinger-lib' + +/* eslint-disable @typescript-eslint/no-unsafe-member-access */ + +// How long to wait after an operation broadcast to move on. +// Blocks on mainnet are 60s, blocks on testnet are 30s. Prefer at least 2 blocks in case of a priority 1 bake. +export const OPERATION_DELAY_SECS = 10 + +export interface ContractOriginationResult { + operationHash: string + contractAddress: string +} + +export function loadContract(filename: string): string { + const contractFile = filename + const contract = fs.readFileSync(contractFile).toString() + return contract +} + +export function initConseil(conseilLogLevel: LogLevelDesc): void { + const logger = getLogger('conseiljs') + logger.setLevel(conseilLogLevel, false) + + registerLogger(logger) + registerFetch(fetch) +} + +export async function sendOperation( + contractAddress: string, + entrypoint: string, + parameter: string, + keystore: KeyStore, + counter: number, + nodeAddress: string, +): Promise { + try { + console.log(`Using counter: ${counter}`) + + const signer = await Utils.signerFromKeyStore(keystore) + + await Utils.revealAccountIfNeeded( + nodeAddress, + keystore, + await Utils.signerFromKeyStore(keystore), + ) + + const operation = TezosNodeWriter.constructContractInvocationOperation( + keystore.publicKeyHash, + counter, + contractAddress, + 0, + 0, + Constants.storageLimit, + Constants.gasLimit, + entrypoint, + parameter, + TezosParameterFormat.Michelson, + ) + + const operationFeeEstimator = new OperationFeeEstimator(nodeAddress) + const operationnWithFees = await operationFeeEstimator.estimateAndApplyFees( + [operation], + ) + + const nodeResult = await TezosNodeWriter.sendOperation( + nodeAddress, + operationnWithFees, + signer, + ) + + const operationHash = nodeResult.operationGroupID + .replace(/"/g, '') + .replace(/\n/, '') + console.log(`Invoked in operation hash: ${operationHash}`) + + // Seems like sometimes Node's mempools run a little slow. + await Utils.sleep(OPERATION_DELAY_SECS) + + return operationHash + } catch (e) { + console.log('Caught exception, retrying...') + console.log(e.message) + await Utils.sleep(OPERATION_DELAY_SECS) + + return sendOperation( + contractAddress, + entrypoint, + parameter, + keystore, + counter, + nodeAddress, + ) + } +} + +export async function deployContract( + contractSource: string, + storage: string, + keystore: KeyStore, + counter: number, + nodeAddress: string, + isMicheline = false, +): Promise { + try { + console.log(`Using storage: ${storage}`) + console.log(`Using counter: ${counter}`) + + await Utils.revealAccountIfNeeded( + nodeAddress, + keystore, + await Utils.signerFromKeyStore(keystore), + ) + + const signer = await Utils.signerFromKeyStore(keystore) + + const operation = TezosNodeWriter.constructContractOriginationOperation( + keystore, + 0, + undefined, + 0, + Constants.storageLimit, + Constants.gasLimit, + contractSource, + storage, + isMicheline + ? TezosParameterFormat.Micheline + : TezosParameterFormat.Michelson, + counter, + ) + + const operationFeeEstimator = new OperationFeeEstimator(nodeAddress) + const operationnWithFees = await operationFeeEstimator.estimateAndApplyFees( + [operation], + ) + + const nodeResult = await TezosNodeWriter.sendOperation( + nodeAddress, + operationnWithFees, + signer, + ) + + const operationHash = nodeResult.operationGroupID + .replace(/"/g, '') + .replace(/\n/, '') + const contractAddress = Utils.calculateContractAddress(operationHash, 0) + + console.log(`Deployed in hash: ${operationHash}`) + console.log(`Deployed contract: ${contractAddress}`) + + // Seems like sometimes Node's mempools run a little slow. + await Utils.sleep(OPERATION_DELAY_SECS) + + return { + operationHash, + contractAddress, + } + } catch (e) { + console.log('Caught exception, retrying...') + console.log(e.message) + await Utils.sleep(OPERATION_DELAY_SECS) + + return deployContract( + contractSource, + storage, + keystore, + counter, + nodeAddress, + isMicheline, + ) + } +} diff --git a/deploy/tsconfig.eslint.json b/deploy/tsconfig.eslint.json new file mode 100644 index 00000000..d42df69b --- /dev/null +++ b/deploy/tsconfig.eslint.json @@ -0,0 +1,10 @@ +// We need this file to run ESLint on our tests +// https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/parser/README.md#configuration +{ + // extend your base config so you don't have to redefine your compilerOptions + "extends": "./tsconfig.json", + "include": [ + "src/**/*.ts", + "__tests__/**/*.ts" + ] +} \ No newline at end of file diff --git a/deploy/tsconfig.json b/deploy/tsconfig.json new file mode 100644 index 00000000..978b5a76 --- /dev/null +++ b/deploy/tsconfig.json @@ -0,0 +1,18 @@ +{ + "compilerOptions": { + "baseUrl": "src", + "rootDir": "./", + "outDir": "build", + "target": "esnext", + "module": "commonjs", + "moduleResolution": "node", + "sourceMap": true, + "removeComments": true, + "strict": true, + "resolveJsonModule": true, + "esModuleInterop": true + }, + "include": [ + "src/*.ts" + ] +} \ No newline at end of file diff --git a/smart_contracts/README.md b/smart_contracts/README.md new file mode 100644 index 00000000..e17ab498 --- /dev/null +++ b/smart_contracts/README.md @@ -0,0 +1,14 @@ +# Smart Contracts + +Smart contracts are written with [SmartPy](https://SmartPy.io). To work with them, you'll need to install the SmartPy CLI. + +## Building + +```shell +$ ./compile.sh +``` + +## Directory Structure + +- `common/`: Shared common code +- `test_helpers/`: Common test code \ No newline at end of file diff --git a/smart_contracts/common/constants.py b/smart_contracts/common/constants.py new file mode 100644 index 00000000..a478630f --- /dev/null +++ b/smart_contracts/common/constants.py @@ -0,0 +1,16 @@ +import smartpy as sp + +# The fixed point number representing 1 in the system, 10^18 +PRECISION = sp.nat(1000000000000000000) + +# The number of seconds to pass before interest is compounded. +SECONDS_PER_COMPOUND = 60 + +# A constant that can be multipled by a mutez to produce a value in Kolibri's scale. +MUTEZ_TO_KOLIBRI_CONVERSION = 1000000000000 + +# The asset pair reported by Harbinger. +ASSET_CODE = "XTZ-USD" + +# The type of data returned in Harbinger's callback. +HARBINGER_DATA_TYPE = sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)) \ No newline at end of file diff --git a/smart_contracts/common/errors.py b/smart_contracts/common/errors.py new file mode 100644 index 00000000..de0a1f10 --- /dev/null +++ b/smart_contracts/common/errors.py @@ -0,0 +1,80 @@ +################################################################ +# Errors from Kolibri contracts. +# +# IMPORTANT: Keep this file in sync with /sdk/src/contract-errors.py. +################################################################ + +# The sender of a contract invocation was required to be a oven. +NOT_OVEN = 1 + +# The sender of a contract invocation was required to be the Oven Proxy contract. +NOT_OVEN_PROXY = 2 + +# The sender of a contract invocation was required to be the Oracle contract. +NOT_ORACLE = 3 + +# The sender of a contract invocation was required to be the Governor contract. +NOT_GOVERNOR = 4 + +# The sender of the contract invocation was required to be the Minter contract. +NOT_MINTER = 5 + +# The sender of an operation was required to be the owner of the Oven contract. +NOT_OWNER = 6 + +# The sender of an operation was required to be the Oven Factory contract. +NOT_OVEN_FACTORY = 7 + +# The sender of an operation was required to be the Administrator of the contract. +NOT_ADMIN = 8 + +# The sender of an operation was required to be the Pause Guardian. +NOT_PAUSE_GUARDIAN = 9 + +# The operation required the oven to be under collateralized. +NOT_UNDER_COLLATERALIZED = 10 + +# The operation caused the oven to become under collateralized. +OVEN_UNDER_COLLATERALIZED = 11 + +# The state machine of the contract was not in the expected state. +BAD_STATE = 12 + +# The destination message was routed to the wrong smart contract. +BAD_DESTINATION = 13 + +# The result contained data for an unexpected asset. +WRONG_ASSET = 14 + +# The request was not allowed to send an amount. +AMOUNT_NOT_ALLOWED = 15 + +# The operation could not be completed because the oven was liquidated. +LIQUIDATED = 16 + +# The data provided was too old. +STALE_DATA = 17 + +# The system is paused. +PAUSED = 18 + +# Cannot receive funds. +CANNOT_RECEIVE_FUNDS = 19 + +# The debt ceiling would be exceeded if the operation were completed. +DEBT_CEILING = 20 + +# The Oven was past the maximum allowed value. +OVEN_MAXIMUM_EXCEEDED = 21 + +# The user was not allowed to perform a token transfer. +TOKEN_NO_TRANSFER_PERMISSION = 22 + +# The user did not have a sufficient token balance to complete the operation. +TOKEN_INSUFFICIENT_BALANCE = 23 + +# The allowance change was unsafe. Please reset the allowance to zero before trying to operation again. +TOKEN_UNSAFE_ALLOWANCE_CHANGE = 23 + +# The operation was not performed by the token administrator. +TOKEN_NOT_ADMINISTRATOR = 24 \ No newline at end of file diff --git a/smart_contracts/common/oven-api.py b/smart_contracts/common/oven-api.py new file mode 100644 index 00000000..c228b5ff --- /dev/null +++ b/smart_contracts/common/oven-api.py @@ -0,0 +1,131 @@ +import smartpy as sp + +################################################################ +# Common Entry Point Names for the Oven -> Oven Proxy -> Minter Abstraction +################################################################ +BORROW_ENTRY_POINT_NAME = "borrow" +REPAY_ENTRY_POINT_NAME = "repay" +DEPOSIT_ENTRY_POINT_NAME = "deposit" +WITHDRAW_ENTRY_POINT_NAME = "withdraw" +LIQUIDATE_ENTRY_POINT_NAME = "liquidate" + +################################################################ +# Common Parameter types for the Oven -> Oven Proxy -> Minter Abstraction +################################################################ + +# Borrow parameter type. +# Elements: +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Nat: The additional number of tokens to borrow. +BORROW_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))) + +# Borrow parameter type with oracle data attached +# Elements: +# - Nat: XTZ-USD value as reported by Oracle. +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Nat: The additional number of tokens to borrow. +BORROW_PARAMETER_TYPE_ORACLE = sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat)))))))) + +# Repay parameter type. +# Elements: +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Nat: The number of tokens to repay. +REPAY_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))) + +# Withdraw parameter type. +# Elements: +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Mutez: The amount to withdraw. +WITHDRAW_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TMutez))))))) + +# Withdraw parameter type with oracle data attached. +# Elements: +# - Nat: XTZ-USD value as reported by Oracle. +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Mutez: The amount to withdraw. +WITHDRAW_PARAMETER_TYPE_ORACLE = sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TMutez)))))))) + +# Deposit parameter type. +# Elements: +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +DEPOSIT_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TInt)))))) + +# Liquidate parameter type. +# Elements: +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Address: The address performing the liquidation +LIQUIDATE_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TAddress))))))) + +# Liquidate parameter type with oracle data attached. +# Elements: +# - Nat: XTZ-USD value as reported by Oracle. +# - Address: The address of the oven +# - Address: The address of the owner +# - Nat: The balance of the oven +# - Nat: The number of borrowed tokens +# - Bool: Whether the oven is liquidated. +# - Int: The number of tokens accrued in stability fees. +# - Int: The interest index for the oven. +# - Address: The address performing the liquidation +LIQUIDATE_PARAMETER_TYPE_ORACLE = sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TAddress)))))))) + +################################################################ +# Common Entry Point Names for the Minter -> Oven Proxy -> Oven Abstraction +################################################################ + +UPDATE_STATE_ENTRY_POINT_NAME = "updateState" + +################################################################ +# Common Entry Point Names for the Minter -> Oven Proxy -> Oven Abstraction +################################################################ + +# Update a Ovens's state. +# Elements: +# - Address: The oven to update +# - Nat: The new value for borrowed tokens +# - Int: The new value for accrued stability fees in tokens. +# - Int: The interest index for the oven. +# - Bool: The new value for is liquidated. +UPDATE_STATE_PARAMETER_TYPE = sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TBool)))) diff --git a/smart_contracts/compile.sh b/smart_contracts/compile.sh new file mode 100755 index 00000000..55a5938c --- /dev/null +++ b/smart_contracts/compile.sh @@ -0,0 +1,79 @@ +#!/usr/bin/env bash + +set -e -o pipefail + +echo "----------------------------------------" +echo "Compiling StableCoin Contracts" +echo "----------------------------------------" + +# Expected location of SmartPy CLI. +SMART_PY_CLI=~/smartpy-cli/SmartPy.sh + +# Output directory +OUT_DIR=./.smartpy_out + +# Parallel sorted arrays. +CONTRACTS_ARRAY=(oven-factory dev-fund token stability-fund minter oven-proxy oracle oven oven-registry) +INVOCATION_ARRAY=("OvenFactoryContract()" "DevFundContract()" "FA12()" "StabilityFundContract()" "MinterContract()" "OvenProxyContract()" "OracleContract()" "OvenContract()" "OvenRegistryContract()") + +# Ensure we have a SmartPy binary. +if [ ! -f "$SMART_PY_CLI" ]; then + echo "Fatal: Please install SmartPy CLI at $SMART_PY_CLI" && exit +fi + +# Compile a contract. +# Args +function processContract { + CONTRACT_NAME=$1 + INVOCATION=$2 + OUT_DIR=$3 + CONTRACT_IN="${CONTRACT_NAME}.py" + CONTRACT_OUT="${CONTRACT_NAME}.tz" + CONTRACT_COMPILED="${CONTRACT_NAME}_compiled.tz" + + echo ">> Processing ${CONTRACT_NAME}" + + # Ensure file exists. + if [ ! -f "$CONTRACT_IN" ]; then + echo "Fatal: $CONTRACT_IN not found. Running from wrong dir?" && exit + fi + + # Test + echo ">>> [1 / 3] Testing ${CONTRACT_NAME} " + $SMART_PY_CLI test $CONTRACT_IN $OUT_DIR + echo ">>> Done" + + echo ">>> [2 / 3] Compiling ${CONTRACT_NAME}" + $SMART_PY_CLI compile $CONTRACT_IN $INVOCATION $OUT_DIR + echo ">>> Done." + + echo ">>> [3 / 3] Copying Artifacts" + cp $OUT_DIR/$CONTRACT_COMPILED $CONTRACT_OUT + echo ">>> Written to ${CONTRACT_OUT}" +} + +echo "> [1 / 3] Unit Testing and Compiling Contracts." +for i in ${!CONTRACTS_ARRAY[@]}; do + echo ">> [$((i + 1)) / ${#CONTRACTS_ARRAY[@]}] Processing ${CONTRACTS_ARRAY[$i]}" + processContract ${CONTRACTS_ARRAY[$i]} ${INVOCATION_ARRAY[$i]} $OUT_DIR + echo ">> Done." + echo "" +done +echo "> Compilation Complete." +echo "" + +# End to End Testing +echo "> [2 / 3] Running End to End Tests" +$SMART_PY_CLI test end-to-end-tests.py $OUT_DIR +echo "> Testing Complete" +echo "" + +# Remove other artifacts to reduce noise. +echo "> [3 / 3] Cleaning up" +rm -rf $OUT_DIR +echo "> All tidied up." +echo "" + +echo "----------------------------------------" +echo "Task complete." +echo "----------------------------------------" \ No newline at end of file diff --git a/smart_contracts/dev-fund.py b/smart_contracts/dev-fund.py new file mode 100644 index 00000000..c5e09374 --- /dev/null +++ b/smart_contracts/dev-fund.py @@ -0,0 +1,395 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +Errors = sp.import_script_from_url("file:common/errors.py") + +################################################################ +# Contract +################################################################ + +class DevFundContract(sp.Contract): + def __init__( + self, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + administratorContractAddress = Addresses.FUND_ADMINISTRATOR_ADDRESS, + tokenContractAddress = Addresses.TOKEN_ADDRESS, + **extra_storage + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + governorContractAddress = governorContractAddress, + administratorContractAddress = administratorContractAddress, + tokenContractAddress = tokenContractAddress, + **extra_storage + ) + + ################################################################ + # Public API + ################################################################ + + # Allow transfers into the fund as a consequence of liquidation. + @sp.entry_point + def default(self, param): + pass + + ################################################################ + # Administrator API + ################################################################ + + @sp.entry_point + def setDelegate(self, newDelegate): + sp.set_type(newDelegate, sp.TOption(sp.TKeyHash)) + + # Verify the caller is the admin. + sp.verify(sp.sender == self.data.administratorContractAddress, message = Errors.NOT_ADMIN) + + sp.set_delegate(newDelegate) + + ################################################################ + # Governance + ################################################################ + + # Governance is timelocked and can always transfer funds. + @sp.entry_point + def send(self, param): + sp.set_type(param, sp.TPair(sp.TMutez, sp.TAddress)) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + sp.send(sp.snd(param), sp.fst(param)) + + # Governance is timelocked and can always transfer funds. + @sp.entry_point + def sendTokens(self, param): + sp.set_type(param, sp.TPair(sp.TNat, sp.TAddress)) + + # Verify sender is governor. + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + + # Destructure parameters. + amount = sp.fst(param) + destination = sp.snd(param) + + # Invoke token contract + tokenContractParam = sp.record( + to_ = destination, + from_ = sp.self_address, + value = amount + ) + contractHandle = sp.contract( + sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress, value = sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), + self.data.tokenContractAddress, + "transfer" + ).open_some() + sp.transfer(tokenContractParam, sp.mutez(0), contractHandle) + + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # Update the administrator contract. + @sp.entry_point + def setAdministratorContract(self, newAdministratorContractAddress): + sp.set_type(newAdministratorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.administratorContractAddress = newAdministratorContractAddress + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + DummyContract = sp.import_script_from_url("file:test-helpers/dummy-contract.py") + MockOvenProxy = sp.import_script_from_url("file:test-helpers/mock-oven-proxy.py") + Oven = sp.import_script_from_url("file:oven.py") + OvenRegistry = sp.import_script_from_url("file:oven-registry.py") + Token = sp.import_script_from_url("file:token.py") + + ################################################################ + # default + ################################################################ + + @sp.add_test(name="default - can receive funds") + def test(): + # GIVEN a DevFund contract + scenario = sp.test_scenario() + + fund = DevFundContract() + scenario += fund + + # WHEN the default entry point is called + amount = sp.mutez(1) + scenario += fund.default(sp.unit).run( + amount = amount, + ) + + # THEN the funds are accepted. + scenario.verify(fund.balance == amount) + + ################################################################ + # setDelegate + ################################################################ + + @sp.add_test(name="setDelegate - fails when not called by administrator") + def test(): + # GIVEN a DevFund without a delegate and an administrator. + scenario = sp.test_scenario() + administrator = Addresses.FUND_ADMINISTRATOR_ADDRESS + + fund = DevFundContract( + administratorContractAddress = administrator + ) + scenario += fund + + # WHEN setDelegate is called by someone other than the administrator THEN the invocation fails. + notAdministrator = Addresses.NULL_ADDRESS + delegate = sp.some(sp.key_hash("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf")) + scenario += fund.setDelegate(delegate).run( + sender = notAdministrator, + valid = False + ) + + @sp.add_test(name="setDelegate - updates delegate") + def test(): + # GIVEN a DevFund contract without a delegate and an administrator. + scenario = sp.test_scenario() + administrator = Addresses.FUND_ADMINISTRATOR_ADDRESS + + fund = DevFundContract( + administratorContractAddress = administrator + ) + scenario += fund + + # WHEN setDelegate is called by the administrator + delegate = sp.some(sp.key_hash("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf")) + scenario += fund.setDelegate(delegate).run( + sender = administrator, + ) + + # THEN the delegate is updated. + scenario.verify(fund.baker.open_some() == delegate.open_some()) + + ################################################################ + # send + ################################################################ + + @sp.add_test(name="send - succeeds when called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a DevFund contract with some balance + balance = sp.mutez(10) + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + fund.set_initial_balance(balance) + scenario += fund + + # AND a dummy contract to receive funds + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN send is called + param = (balance, dummyContract.address) + scenario += fund.send(param).run( + sender = governorContractAddress, + ) + + # THEN the funds are sent. + scenario.verify(fund.balance == sp.mutez(0)) + scenario.verify(dummyContract.balance == balance) + + @sp.add_test(name="send - fails when not called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a DevFund contract + balance = sp.mutez(10) + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + fund.set_initial_balance(balance) + scenario += fund + + # WHEN send is called by someone who isn't the governor THEN the call fails + notGovernor = Addresses.NULL_ADDRESS + param = (balance, notGovernor) + scenario += fund.send(param).run( + sender = notGovernor, + valid = False + ) + ################################################################ + # sendTokens + ################################################################ + + @sp.add_test(name="sendTokens - succeeds when called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND a DevFund contract + fund = DevFundContract( + governorContractAddress = governorAddress, + tokenContractAddress = token.address + ) + scenario += fund + + # And a dummy contract to send to. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # AND the fund has $1000 of tokens. + fundTokens = 1000 * Constants.PRECISION + mintForFundParam = sp.record(address = fund.address, value = fundTokens) + scenario += token.mint(mintForFundParam).run( + sender = governorAddress + ) + + # WHEN sendTokens is called + amount = sp.nat(200) + param = (amount, dummyContract.address) + scenario += fund.sendTokens(param).run( + sender = governorAddress, + ) + + # THEN the fund is debited tokens + scenario.verify(token.data.balances[fund.address].balance == sp.as_nat(fundTokens - amount)) + + # AND the receiver was credited the tokens. + scenario.verify(token.data.balances[dummyContract.address].balance == amount) + + @sp.add_test(name="sendTokens - fails when not called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND a DevFund contract + fund = DevFundContract( + governorContractAddress = governorAddress, + tokenContractAddress = token.address + ) + scenario += fund + + # AND the fund has $1000 of tokens. + fundTokens = 1000 * Constants.PRECISION + mintForFundParam = sp.record(address = fund.address, value = fundTokens) + scenario += token.mint(mintForFundParam).run( + sender = governorAddress + ) + + # WHEN sendTokens is called by someone who isn't the governor THEN the call fails. + notGovernor = Addresses.NULL_ADDRESS + amount = sp.nat(200) + param = (amount, Addresses.ROTATED_ADDRESS) + scenario += fund.sendTokens(param).run( + sender = notGovernor, + valid = False + ) + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN a DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setGovernorContract is called with a new contract + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += fund.setGovernorContract(rotatedAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(fund.data.governorContractAddress == rotatedAddress) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN a DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += fund.setGovernorContract(rotatedAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setAdministratorContract + ################################################################ + + @sp.add_test(name="setAdministratorContract - succeeds when called by governor") + def test(): + # GIVEN an DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setAdministratorContract is called with a new contract + rotatedAddress= Addresses.ROTATED_ADDRESS + scenario += fund.setAdministratorContract(rotatedAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(fund.data.administratorContractAddress == rotatedAddress) + + @sp.add_test(name="setAdministratorContract - fails when not called by governor") + def test(): + # GIVEN a DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = DevFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setAdministratorContract is called by someone who isn't the governor THEN the call fails + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += fund.setAdministratorContract(rotatedAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) diff --git a/smart_contracts/dev-fund.tz b/smart_contracts/dev-fund.tz new file mode 100644 index 00000000..354b260d --- /dev/null +++ b/smart_contracts/dev-fund.tz @@ -0,0 +1,177 @@ +parameter (or (or (unit %default) (or (pair %send mutez address) (pair %sendTokens nat address))) (or (address %setAdministratorContract) (or (option %setDelegate key_hash) (address %setGovernorContract)))); +storage (pair (address %administratorContractAddress) (pair (address %governorContractAddress) (address %tokenContractAddress))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + DROP; # @storage + # == default == # @storage + NIL operation; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%send + # == send == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%send + DUP; # @storage : @storage : @parameter%send + DUG 2; # @storage : @parameter%send : @storage + CDAR; # address : @parameter%send : @storage + SENDER; # address : address : @parameter%send : @storage + COMPARE; # int : @parameter%send : @storage + EQ; # bool : @parameter%send : @storage + IF + {} + { + PUSH int 4; # int : @parameter%send : @storage + FAILWITH; # FAILED + }; # @parameter%send : @storage + # sp.send(sp.snd(params), sp.fst(params)) # @parameter%send : @storage + DUP; # @parameter%send : @parameter%send : @storage + CDR; # address : @parameter%send : @storage + CONTRACT unit; # option (contract unit) : @parameter%send : @storage + IF_SOME + {} + { + UNIT; # unit : @parameter%send : @storage + FAILWITH; # FAILED + }; # @some : @parameter%send : @storage + NIL operation; # list operation : @some : @parameter%send : @storage + SWAP; # @some : list operation : @parameter%send : @storage + DIG 2; # @parameter%send : @some : list operation : @storage + CAR; # mutez : @some : list operation : @storage + UNIT; # unit : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%sendTokens + # == sendTokens == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%sendTokens + DUP; # @storage : @storage : @parameter%sendTokens + DUG 2; # @storage : @parameter%sendTokens : @storage + CDAR; # address : @parameter%sendTokens : @storage + SENDER; # address : address : @parameter%sendTokens : @storage + COMPARE; # int : @parameter%sendTokens : @storage + EQ; # bool : @parameter%sendTokens : @storage + IF + {} + { + PUSH int 4; # int : @parameter%sendTokens : @storage + FAILWITH; # FAILED + }; # @parameter%sendTokens : @storage + # sp.transfer(sp.record(from_ = sp.self_address, to_ = sp.snd(params), value = sp.fst(params)), sp.tez(0), sp.contract(sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress, value = sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.tokenContractAddress, entry_point='transfer').open_some()) # @parameter%sendTokens : @storage + NIL operation; # list operation : @parameter%sendTokens : @storage + DIG 2; # @storage : list operation : @parameter%sendTokens + DUP; # @storage : @storage : list operation : @parameter%sendTokens + DUG 3; # @storage : list operation : @parameter%sendTokens : @storage + CDDR; # address : list operation : @parameter%sendTokens : @storage + CONTRACT %transfer (pair (address %from) (pair (address %to) (nat %value))); # option (contract (pair (address %from) (pair (address %to) (nat %value)))) : list operation : @parameter%sendTokens : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%sendTokens : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%sendTokens : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%sendTokens : @storage + DIG 3; # @parameter%sendTokens : mutez : @some : list operation : @storage + DUP; # @parameter%sendTokens : @parameter%sendTokens : mutez : @some : list operation : @storage + CAR; # nat : @parameter%sendTokens : mutez : @some : list operation : @storage + SWAP; # @parameter%sendTokens : nat : mutez : @some : list operation : @storage + CDR; # address : nat : mutez : @some : list operation : @storage + PAIR %to %value; # pair (address %to) (nat %value) : mutez : @some : list operation : @storage + SELF; # contract (or (or (unit %default) (or (pair %send mutez address) (pair %sendTokens nat address))) (or (address %setAdministratorContract) (or (option %setDelegate key_hash) (address %setGovernorContract)))) : pair (address %to) (nat %value) : mutez : @some : list operation : @storage + ADDRESS; # address : pair (address %to) (nat %value) : mutez : @some : list operation : @storage + PAIR %from; # pair (address %from) (pair (address %to) (nat %value)) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setAdministratorContract + # == setAdministratorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setAdministratorContract + DUP; # @storage : @storage : @parameter%setAdministratorContract + DUG 2; # @storage : @parameter%setAdministratorContract : @storage + CDAR; # address : @parameter%setAdministratorContract : @storage + SENDER; # address : address : @parameter%setAdministratorContract : @storage + COMPARE; # int : @parameter%setAdministratorContract : @storage + EQ; # bool : @parameter%setAdministratorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setAdministratorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setAdministratorContract : @storage + SWAP; # @storage : @parameter%setAdministratorContract + # self.data.administratorContractAddress = params # @storage : @parameter%setAdministratorContract + CDR; # pair (address %governorContractAddress) (address %tokenContractAddress) : @parameter%setAdministratorContract + SWAP; # @parameter%setAdministratorContract : pair (address %governorContractAddress) (address %tokenContractAddress) + PAIR; # pair @parameter%setAdministratorContract (pair (address %governorContractAddress) (address %tokenContractAddress)) + NIL operation; # list operation : pair @parameter%setAdministratorContract (pair (address %governorContractAddress) (address %tokenContractAddress)) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setDelegate + # == setDelegate == + # sp.verify(sp.sender == self.data.administratorContractAddress, message = 8) # @storage : @parameter%setDelegate + DUP; # @storage : @storage : @parameter%setDelegate + DUG 2; # @storage : @parameter%setDelegate : @storage + CAR; # address : @parameter%setDelegate : @storage + SENDER; # address : address : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 8; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.set_delegate(params) # @parameter%setDelegate : @storage + SET_DELEGATE; # operation : @storage + NIL operation; # list operation : operation : @storage + SWAP; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CDAR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CAR; # address : @storage : @parameter%setGovernorContract + SWAP; # @storage : address : @parameter%setGovernorContract + CDDR; # address : address : @parameter%setGovernorContract + DIG 2; # @parameter%setGovernorContract : address : address + PAIR; # pair @parameter%setGovernorContract address : address + SWAP; # address : pair @parameter%setGovernorContract address + PAIR; # pair address (pair @parameter%setGovernorContract address) + NIL operation; # list operation : pair address (pair @parameter%setGovernorContract address) + }; # list operation : @storage + }; # list operation : pair @parameter%setAdministratorContract (pair (address %governorContractAddress) (address %tokenContractAddress)) + }; # list operation : @storage + PAIR; # pair (list operation) @storage + }; \ No newline at end of file diff --git a/smart_contracts/end-to-end-tests.py b/smart_contracts/end-to-end-tests.py new file mode 100644 index 00000000..fcc8a242 --- /dev/null +++ b/smart_contracts/end-to-end-tests.py @@ -0,0 +1,783 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +DevFund = sp.import_script_from_url("file:dev-fund.py") +Dummy = sp.import_script_from_url("file:test-helpers/dummy-contract.py") +FakeHarbinger = sp.import_script_from_url("file:test-helpers/fake-harbinger.py") +Minter = sp.import_script_from_url("file:minter.py") +Oracle = sp.import_script_from_url("file:oracle.py") +Oven = sp.import_script_from_url("file:oven.py") +OvenFactory = sp.import_script_from_url("file:oven-factory.py") +OvenProxy = sp.import_script_from_url("file:oven-proxy.py") +OvenRegistry = sp.import_script_from_url("file:oven-registry.py") +StabilityFund = sp.import_script_from_url("file:stability-fund.py") +Token= sp.import_script_from_url("file:token.py") + +@sp.add_test(name="End to End Tests - Alice can deposit and withdraw from oven") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + liquidationFeePercent = sp.nat(100000000000000000) # 10% + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + lastInterestIndexUpdateTime = currentTime, + stabilityDevFundSplit = stabilityDevFundSplit, + liquidationFeePercent = liquidationFeePercent + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven. + aliceOven = Oven.OvenContract(owner = alice.address, ovenProxyContractAddress = ovenProxy.address) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # VERIFY alice can deposit into the oven. + currentTime = currentTime.add_seconds(1) + amount = sp.tez(10) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = amount, now = currentTime) + scenario.verify(aliceOven.balance == amount) + + # VERIFY alice can withdraw from the oven. + currentTime = currentTime.add_seconds(1) + scenario += aliceOven.withdraw(amount).run(sender = alice.address, now = currentTime) + scenario.verify(aliceOven.balance == sp.tez(0)) + scenario.verify(alice.balance == amount) + +@sp.add_test(name="End to End Tests - Alice can borrow and repay tokens") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + liquidationFeePercent = sp.nat(100000000000000000) # 10% + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + lastInterestIndexUpdateTime = currentTime, + stabilityDevFundSplit = stabilityDevFundSplit, + liquidationFeePercent = liquidationFeePercent + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven. + aliceOven = Oven.OvenContract(owner = alice.address, ovenProxyContractAddress = ovenProxy.address) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # VERIFY alice can deposit into the oven and then mint tokens + currentTime = currentTime.add_seconds(1) + amount = sp.tez(10) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = amount, now = currentTime) + currentTime = currentTime.add_seconds(1) + borrowAmount = 5 * Constants.PRECISION + scenario += aliceOven.borrow(borrowAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(aliceOven.balance == amount) + scenario.verify(token.data.balances[alice.address].balance == borrowAmount) + + # VERIFY alice can repay the borrowed tokens and withdraw collateral. + currentTime = currentTime.add_seconds(1) + scenario += aliceOven.repay(borrowAmount).run(sender = alice.address, now = currentTime) + currentTime = currentTime.add_seconds(1) + scenario += aliceOven.withdraw(amount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == sp.nat(0)) + scenario.verify(aliceOven.balance == sp.tez(0)) + scenario.verify(alice.balance == amount) + +@sp.add_test(name="End to End Tests - Alice can borrow and repay tokens incrementally") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + liquidationFeePercent = sp.nat(100000000000000000) # 10% + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + lastInterestIndexUpdateTime = currentTime, + stabilityDevFundSplit = stabilityDevFundSplit, + liquidationFeePercent = liquidationFeePercent + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven. + aliceOven = Oven.OvenContract(owner = alice.address, ovenProxyContractAddress = ovenProxy.address) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # VERIFY alice can withdraw partial amounts of collateral after repaying + # Alice deposits $20 of XTZ and mints $10 of kUSD + currentTime = currentTime.add_seconds(1) + amount = sp.tez(10) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = amount, now = currentTime) + currentTime = currentTime.add_seconds(1) + borrowAmount = 10 * Constants.PRECISION + scenario += aliceOven.borrow(borrowAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 10 * Constants.PRECISION) + scenario.verify(aliceOven.balance == sp.tez(10)) + + # Alice repays $2 of kUSD + currentTime = currentTime.add_seconds(1) + repayAmount = 2 * Constants.PRECISION + scenario += aliceOven.repay(repayAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 8 * Constants.PRECISION) + scenario.verify(aliceOven.balance == sp.tez(10)) + + # Alice can now withdraw $4 of XTZ + currentTime = currentTime.add_seconds(1) + withdrawAmount = sp.mutez(2000000) + scenario += aliceOven.withdraw(withdrawAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 8 * Constants.PRECISION) + scenario.verify(aliceOven.balance == sp.tez(8)) + scenario.verify(alice.balance == withdrawAmount) + + # Alice can repay and withdraw all the remaining collateral. + currentTime = currentTime.add_seconds(1) + repayAmount = 8 * Constants.PRECISION + scenario += aliceOven.repay(repayAmount).run(sender = alice.address, now = currentTime) + currentTime = currentTime.add_seconds(1) + withdrawAmount = sp.mutez(8000000) + scenario += aliceOven.withdraw(withdrawAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 0) + scenario.verify(aliceOven.balance == sp.tez(0)) + scenario.verify(alice.balance == amount) + +@sp.add_test(name="End to End Tests - Bob can liquidate Alices oven") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + liquidationFeePercent = sp.nat(100000000000000000) # 10% + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + lastInterestIndexUpdateTime = currentTime, + stabilityDevFundSplit = stabilityDevFundSplit, + liquidationFeePercent = liquidationFeePercent + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven. + aliceOven = Oven.OvenContract(owner = alice.address, ovenProxyContractAddress = ovenProxy.address) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # VERIFY Bob can liquidate an oven. + # Alice deposits $20 of XTZ and mints $10 of kUSD + currentTime = currentTime.add_seconds(1) + amount = sp.tez(10) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = amount, now = currentTime) + currentTime = currentTime.add_seconds(1) + borrowAmount = 10 * Constants.PRECISION + scenario += aliceOven.borrow(borrowAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 10 * Constants.PRECISION) + scenario.verify(aliceOven.balance == amount) + + # The price of XTZ crashes to $1, XTZ is now worth $10 and kUSD is worth $10 + scenario += fakeHarbinger.setNewPrice(100000) + + # A new actor, Bob, notices this. Bob has many tokens. + bob = Dummy.DummyContract() + scenario += bob + + bobTokenAmount = 100 * Constants.PRECISION + scenario += token.mint(sp.record(address = bob.address, value = bobTokenAmount)).run(sender = minter.address) + scenario.verify(token.data.balances[bob.address].balance == bobTokenAmount) + + # Bob liquidates Alice's oven. + currentTime = currentTime.add_seconds(1) + scenario += aliceOven.liquidate(sp.unit).run(sender = bob.address, now = currentTime) + + # Bob loses the tokens needed to repay the collateral. + liquidationfee = borrowAmount // 10 # 10% of borrowed amount + bobTokensLessRepayAmount = sp.as_nat(bobTokenAmount - borrowAmount) + bobTokensLessRepayAmountAndLiquidationFee = sp.as_nat(bobTokensLessRepayAmount - liquidationfee) + scenario.verify(token.data.balances[bob.address].balance == bobTokensLessRepayAmountAndLiquidationFee) + + # Developer fund received 10% of liquidation fee + expectedDevFundValue = (borrowAmount // 10) // 10 # 10% of borrowed amount + scenario.verify(token.data.balances[developerFund.address].balance == expectedDevFundValue) + + # Stability fund received the remainder of the liquidation fee + expectedStabilityFundValue = ((borrowAmount // 10) // 10) * 9 # 90% of borrowed amount + scenario.verify(token.data.balances[stabilityFund.address].balance == expectedStabilityFundValue) + + # Bob received the collateral. + scenario.verify(bob.balance == amount) + + # Alice's oven is now liquidated. + scenario.verify(aliceOven.data.isLiquidated == True) + +@sp.add_test(name="End to End Tests - Stability Fund can liquidate Alices oven") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + liquidationFeePercent = sp.nat(100000000000000000) # 10% + administrator = Dummy.DummyContract() + developerFund = DevFund.DevFundContract( + administratorContractAddress = administrator.address + ) + stabilityFund = StabilityFund.StabilityFundContract( + administratorContractAddress = administrator.address + ) + minter = Minter.MinterContract( + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + lastInterestIndexUpdateTime = currentTime, + stabilityDevFundSplit = stabilityDevFundSplit, + liquidationFeePercent = liquidationFeePercent + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += administrator + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven. + aliceOven = Oven.OvenContract(owner = alice.address, ovenProxyContractAddress = ovenProxy.address) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # VERIFY the StabilityFund can liquidate an oven. + # Alice deposits $20 of XTZ and mints $10 of kUSD + currentTime = currentTime.add_seconds(1) + amount = sp.tez(10) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = amount, now = currentTime) + currentTime = currentTime.add_seconds(1) + borrowAmount = 10 * Constants.PRECISION + scenario += aliceOven.borrow(borrowAmount).run(sender = alice.address, now = currentTime) + + scenario.verify(token.data.balances[alice.address].balance == 10 * Constants.PRECISION) + scenario.verify(aliceOven.balance == sp.tez(10)) + + # The price of XTZ crashes to $1, XTZ is now worth $10 and kUSD is worth $10 + scenario += fakeHarbinger.setNewPrice(100000) + + # The stability fund has many tokens + stabilityFundTokenAmount = 100 * Constants.PRECISION + scenario += token.mint(sp.record(address = stabilityFund.address, value = stabilityFundTokenAmount)).run(sender = minter.address) + scenario.verify(token.data.balances[stabilityFund.address].balance == stabilityFundTokenAmount) + + # The administrator notices Alice's oven is liquidatable and instructs the stability fund to liquidated it. + currentTime = currentTime.add_seconds(1) + scenario += stabilityFund.liquidate(aliceOven.address).run(sender = administrator.address, now = currentTime) + + # The stability fund loses the tokens needed to repay the collateral, and gains 90% of the liquidation fee + liquidationfee = borrowAmount // 10 # 10% of borrowed amount + stabilityFundTokensLessRepayAmount = sp.as_nat(stabilityFundTokenAmount - borrowAmount) + stabilityFundTokensLessRepayAmountAndLiquidationFee = sp.as_nat(stabilityFundTokensLessRepayAmount - liquidationfee) + expectedStabilityFundTokensFromLiquidation = ((borrowAmount // 10) // 10) * 9 # 90% of borrowed amount + expectedDevFundValue = stabilityFundTokensLessRepayAmountAndLiquidationFee + expectedStabilityFundTokensFromLiquidation + scenario.verify(token.data.balances[stabilityFund.address].balance == expectedDevFundValue) + + # Developer fund received 10% of liquidation fee + expectedDevFundValue = (borrowAmount // 10) // 10 # 10% of borrowed amount + scenario.verify(token.data.balances[developerFund.address].balance == expectedDevFundValue) + + # The stability fund received the collateral. + scenario.verify(stabilityFund.balance == amount) + + # Alice's oven is now liquidated. + scenario.verify(aliceOven.data.isLiquidated == True) + + # And the Administrator received no XTZ and has no record of a balance of kUSD + scenario.verify(administrator.balance == sp.tez(0)) + scenario.verify(token.data.balances.contains(administrator.address) == False) + +@sp.add_test(name="End to End Tests - Fees are accrued - Alices oven in sync with minter interest index") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts, which exist at compound period 1 + lastInterestIndexUpdateTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + stabilityFee = sp.nat(100000000000000000) # 10% + initialInterestIndex = 1100000000000000000 # 1.10 + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + stabilityFee = stabilityFee, + lastInterestIndexUpdateTime = lastInterestIndexUpdateTime, + interestIndex = initialInterestIndex + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven with an interest index the same as the minter. + aliceBorrowedTokens = 10 * Constants.PRECISION + aliceStabilityFeeTokens = sp.int(0) + aliceOven = Oven.OvenContract( + owner = alice.address, + borrowedTokens = aliceBorrowedTokens, + stabilityFeeTokens = aliceStabilityFeeTokens, + ovenProxyContractAddress = ovenProxy.address, + interestIndex = sp.to_int(initialInterestIndex) + ) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # WHEN alice deposits 1 XTZ at compound period = 2 + currentTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND * 2) + depositAmount = sp.tez(1) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = depositAmount, now = currentTime) + + # THEN the minter compounds its interest index for one period + expectedInterestIndex = 1210000000000000000 + scenario.verify(minter.data.interestIndex == expectedInterestIndex) + + # AND the minter sets the last updated time to the current time. + scenario.verify(minter.data.lastInterestIndexUpdateTime == currentTime) + + # AND the oven receives the same interest index + scenario.verify(aliceOven.data.interestIndex == expectedInterestIndex) + + # AND stability tokens compounded once + newTokensAccruedAsStabilityFeesFromStabilityFees = sp.as_nat(aliceStabilityFeeTokens) // 10 + newTokensAccruedAsStabiiltyFeesFromBorrowedTokens = aliceBorrowedTokens // 10 + expectedStabilityTokensAfterFirstCompound = sp.as_nat(aliceStabilityFeeTokens) + newTokensAccruedAsStabilityFeesFromStabilityFees + newTokensAccruedAsStabiiltyFeesFromBorrowedTokens + # scenario.verify(expectedStabilityTokensAfterFirstCompound == sp.nat(1000000000000000000)) # Sanity check + scenario.verify(aliceOven.data.stabilityFeeTokens == sp.to_int(expectedStabilityTokensAfterFirstCompound)) + + # WHEN alice deposits 1 XTZ at compound period = 3 + currentTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND * 3) + depositAmount = sp.tez(1) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = depositAmount, now = currentTime) + + # THEN the minter compounds its interest index for one period + expectedInterestIndex = 1331000000000000000 + scenario.verify(minter.data.interestIndex == expectedInterestIndex) + + # AND the minter sets the last updated time to the current time. + scenario.verify(minter.data.lastInterestIndexUpdateTime == currentTime) + + # AND the oven receives the same interest index + scenario.verify(aliceOven.data.interestIndex == expectedInterestIndex) + + # AND stability tokens compounded the second time. + scenario.verify(aliceOven.data.stabilityFeeTokens == sp.to_int(2100000000000000000)) + +@sp.add_test(name="End to End Tests - Fees are accrued - Alices oven out of sync with minter interest index") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts, which exist at compound period 1 + lastInterestIndexUpdateTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + stabilityFee = sp.nat(100000000000000000) # 10% + initialInterestIndex = 1100000000000000000 # 1.10 + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + stabilityFee = stabilityFee, + lastInterestIndexUpdateTime = lastInterestIndexUpdateTime, + interestIndex = initialInterestIndex + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven with interest index = 1 + aliceBorrowedTokens = 10 * Constants.PRECISION + aliceStabilityFeeTokens = sp.int(0) + aliceOven = Oven.OvenContract( + owner = alice.address, + borrowedTokens = aliceBorrowedTokens, + stabilityFeeTokens = aliceStabilityFeeTokens, + ovenProxyContractAddress = ovenProxy.address, + interestIndex = sp.to_int(Constants.PRECISION) + ) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # WHEN alice deposits 1 XTZ at compound period = 2 + currentTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND * 2) + depositAmount = sp.tez(1) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = depositAmount, now = currentTime) + + # THEN the minter compounds its interest index for one period + expectedInterestIndex = 1210000000000000000 + scenario.verify(minter.data.interestIndex == expectedInterestIndex) + + # AND the minter sets the last updated time to the current time. + scenario.verify(minter.data.lastInterestIndexUpdateTime == currentTime) + + # AND the oven receives the same interest index + scenario.verify(aliceOven.data.interestIndex == expectedInterestIndex) + + # AND stability tokens are compounded twice + newTokensAccruedAsStabilityFeesFromStabilityFees = sp.as_nat(aliceStabilityFeeTokens) // 10 + newTokensAccruedAsStabiiltyFeesFromBorrowedTokens = aliceBorrowedTokens // 10 + expectedStabilityTokensAfterFirstCompound = sp.as_nat(aliceStabilityFeeTokens) + newTokensAccruedAsStabilityFeesFromStabilityFees + newTokensAccruedAsStabiiltyFeesFromBorrowedTokens + # scenario.verify(expectedStabilityTokensAfterFirstCompound == sp.nat(1000000000000000000)) # Sanity check + newTokensAccruedAsStabilityFeesFromStabilityFees = expectedStabilityTokensAfterFirstCompound // 10 + expectedStabilityTokensAfterSecondCompound = expectedStabilityTokensAfterFirstCompound + newTokensAccruedAsStabilityFeesFromStabilityFees + newTokensAccruedAsStabiiltyFeesFromBorrowedTokens + # scenario.verify(expectedStabilityTokensAfterSecondCompound == sp.nat(2100000000000000000)) # Sanity check + scenario.verify(aliceOven.data.stabilityFeeTokens == sp.to_int(expectedStabilityTokensAfterSecondCompound)) + +@sp.add_test(name="End to End Tests - Fees are accrued - multiple time periods elapsed") +def test(): + scenario = sp.test_scenario() + + # GIVEN the beginning of time itself + currentTime = sp.timestamp(0) + + # AND a fake harbinger contract. + fakeHarbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = sp.nat(2 * 1000000), # $2 + harbingerUpdateTime = currentTime + ) + scenario += fakeHarbinger + + # AND a universe of Stablecoin contracts + lastInterestIndexUpdateTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + stabilityFee = sp.nat(100000000000000000) # 10% + initialInterestIndex = 1100000000000000000 # 1.10 + developerFund = DevFund.DevFundContract() + stabilityFund = StabilityFund.StabilityFundContract() + minter = Minter.MinterContract( + stabilityFee = stabilityFee, + lastInterestIndexUpdateTime = lastInterestIndexUpdateTime, + interestIndex = initialInterestIndex + ) + oracle = Oracle.OracleContract(harbingerContractAddress = fakeHarbinger.address) + ovenFactory = OvenFactory.OvenFactoryContract() + ovenProxy = OvenProxy.OvenProxyContract() + ovenRegistry = OvenRegistry.OvenRegistryContract() + token = Token.FA12() + + scenario += developerFund + scenario += stabilityFund + scenario += minter + scenario += oracle + scenario += ovenFactory + scenario += ovenProxy + scenario += ovenRegistry + scenario += token + + # AND a user, Alice. + alice = Dummy.DummyContract() + scenario += alice + + # AND the contracts are wired together + scenario += stabilityFund.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += minter.updateContracts((Addresses.GOVERNOR_ADDRESS, (token.address, (ovenProxy.address, (stabilityFund.address, developerFund.address))))).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setOvenProxyContract(ovenProxy.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenFactory.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setMinterContract(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOvenRegistryContract(ovenRegistry.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += ovenProxy.setOracleContract(oracle.address).run(sender= Addresses.GOVERNOR_ADDRESS) + scenario += ovenRegistry.setOvenFactoryContract(ovenFactory.address).run(sender = Addresses.GOVERNOR_ADDRESS) + scenario += token.setAdministrator(minter.address).run(sender = Addresses.GOVERNOR_ADDRESS) + + # AND alice has an oven with interest index = 1 + aliceBorrowedTokens = 10 * Constants.PRECISION + aliceStabilityFeeTokens = sp.int(0) + aliceOven = Oven.OvenContract( + owner = alice.address, + borrowedTokens = aliceBorrowedTokens, + stabilityFeeTokens = aliceStabilityFeeTokens, + ovenProxyContractAddress = ovenProxy.address, + interestIndex = sp.to_int(initialInterestIndex) + ) + scenario += ovenRegistry.addOven((aliceOven.address, alice.address)).run(sender = ovenFactory.address) + scenario += aliceOven + + # WHEN alice deposits 1 XTZ at compound period = 3 + currentTime = sp.timestamp(Constants.SECONDS_PER_COMPOUND * 3) + depositAmount = sp.tez(1) + scenario += aliceOven.default(sp.unit).run(sender = alice.address, amount = depositAmount, now = currentTime) + + # THEN the minter compounds its interest index for two periods using linear approximatoin + expectedInterestIndex = 1320000000000000000 + scenario.verify(minter.data.interestIndex == expectedInterestIndex) + + # AND the minter sets the last updated time to the current time. + scenario.verify(minter.data.lastInterestIndexUpdateTime == currentTime) + + # AND the oven receives the same interest index + scenario.verify(aliceOven.data.interestIndex == expectedInterestIndex) + + # AND stability tokens are compounded twice using linear approximation + scenario.verify(aliceOven.data.stabilityFeeTokens == sp.to_int(2000000000000000000)) diff --git a/smart_contracts/minter.py b/smart_contracts/minter.py new file mode 100644 index 00000000..54c19910 --- /dev/null +++ b/smart_contracts/minter.py @@ -0,0 +1,2501 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +Errors = sp.import_script_from_url("file:common/errors.py") +OvenApi = sp.import_script_from_url("file:common/oven-api.py") + +################################################################ +# Contract +################################################################ + +class MinterContract(sp.Contract): + def __init__( + self, + tokenContractAddress = Addresses.TOKEN_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS, + stabilityFundContractAddress = Addresses.STABILITY_FUND_ADDRESS, + developerFundContractAddress = Addresses.DEVELOPER_FUND_ADDRESS, + collateralizationPercentage = sp.nat(200000000000000000000), # 200% + stabilityFee = sp.nat(0), + lastInterestIndexUpdateTime = sp.timestamp(1601871456), + interestIndex = 1000000000000000000, + stabilityDevFundSplit = sp.nat(100000000000000000), # 10% + liquidationFeePercent = sp.nat(80000000000000000), # 8% + ovenMax = sp.some(sp.tez(100)) + ): + self.exception_optimization_level = "DefaultUnit" + self.add_flag("no_comment") + + self.init( + governorContractAddress = governorContractAddress, + tokenContractAddress = tokenContractAddress, + ovenProxyContractAddress = ovenProxyContractAddress, + collateralizationPercentage = collateralizationPercentage, + developerFundContractAddress = developerFundContractAddress, + stabilityFundContractAddress = stabilityFundContractAddress, + liquidationFeePercent = liquidationFeePercent, + stabilityDevFundSplit = stabilityDevFundSplit, + ovenMax = ovenMax, + + # Interest Calculations + interestIndex = interestIndex, + stabilityFee = stabilityFee, + lastInterestIndexUpdateTime = lastInterestIndexUpdateTime, + ) + + ################################################################ + # Public Interface + ################################################################ + + # Get interest index + @sp.entry_point + def getInterestIndex(self, param): + sp.set_type(param, sp.TContract(sp.TNat)) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Compound interest + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Transfer results to requester. + sp.transfer(newMinterInterestIndex, sp.mutez(0), param) + + # Update internal state. + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + ################################################################ + # Oven Interface + ################################################################ + + # borrow + @sp.entry_point + def borrow(self, param): + sp.set_type(param, OvenApi.BORROW_PARAMETER_TYPE_ORACLE) + + # Verify the sender is the oven proxy. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + + # Destructure input params. + oraclePrice, pair1 = sp.match_pair(param) + ovenAddress, pair2 = sp.match_pair(pair1) + ownerAddress, pair3 = sp.match_pair(pair2) + ovenBalance, pair4 = sp.match_pair(pair3) + borrowedTokens, pair5 = sp.match_pair(pair4) + isLiquidated, pair6 = sp.match_pair(pair5) + stabilityFeeTokensInt, pair7 = sp.match_pair(pair6) + interestIndex = sp.fst(pair7) + tokensToBorrow = sp.snd(pair7) + + stabilityFeeTokens = sp.as_nat(stabilityFeeTokensInt) + + sp.set_type(oraclePrice, sp.TNat) + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(ownerAddress, sp.TAddress) + sp.set_type(ovenBalance, sp.TNat) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TInt) + sp.set_type(tokensToBorrow, sp.TNat) + + # Calculate new interest indices for the minter and the oven. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Disallow repay operations on liquidated ovens. + sp.verify(isLiquidated == False, message = Errors.LIQUIDATED) + + # Calculate newly accrued stability fees and determine total fees. + accruedStabilityFeeTokens = self.calculateNewAccruedInterest((interestIndex, (borrowedTokens, (stabilityFeeTokens, (newMinterInterestIndex))))) + newStabilityFeeTokens = stabilityFeeTokens + accruedStabilityFeeTokens + + # Compute new borrowed amount. + newTotalBorrowedTokens = borrowedTokens + tokensToBorrow + sp.set_type(newTotalBorrowedTokens, sp.TNat) + + # Verify the oven is not under-collateralized. + totalOutstandingTokens = newTotalBorrowedTokens + newStabilityFeeTokens + sp.set_type(totalOutstandingTokens, sp.TNat) + sp.if totalOutstandingTokens > 0: + newCollateralizationPercentage = self.computeCollateralizationPercentage((ovenBalance, (oraclePrice, totalOutstandingTokens))) + sp.verify(newCollateralizationPercentage >= self.data.collateralizationPercentage, message = Errors.OVEN_UNDER_COLLATERALIZED) + + # Call mint in token contract + self.mintTokens(tokensToBorrow, ownerAddress) + + # Inform oven of new state. + self.updateOvenState(ovenAddress, newTotalBorrowedTokens, newStabilityFeeTokens, newMinterInterestIndex, isLiquidated, sp.balance) + + # Update internal state + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + # repay + @sp.entry_point + def repay(self, param): + sp.set_type(param, OvenApi.REPAY_PARAMETER_TYPE) + + # Verify the sender is the oven proxy. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + + # Destructure input params. + ovenAddress, pair1 = sp.match_pair(param) + ownerAddress, pair2 = sp.match_pair(pair1) + ovenBalance, pair3 = sp.match_pair(pair2) + borrowedTokens, pair4 = sp.match_pair(pair3) + isLiquidated, pair5 = sp.match_pair(pair4) + stabilityFeeTokensInt, pair6 = sp.match_pair(pair5) + interestIndex = sp.fst(pair6) + tokensToRepay = sp.snd(pair6) + + stabilityFeeTokens = sp.as_nat(stabilityFeeTokensInt) + + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(ownerAddress, sp.TAddress) + sp.set_type(ovenBalance, sp.TNat) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TInt) + sp.set_type(tokensToRepay, sp.TNat) + + # Calculate new interest indices for the minter and the oven. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Disallow repay operations on liquidated ovens. + sp.verify(isLiquidated == False, message = Errors.LIQUIDATED) + + # Calculate newly accrued stability fees and determine total fees. + accruedStabilityFeeTokens = self.calculateNewAccruedInterest((interestIndex, (borrowedTokens, (stabilityFeeTokens, (newMinterInterestIndex))))) + newStabilityFeeTokens = stabilityFeeTokens + accruedStabilityFeeTokens + + # Determine new values for stability fee tokens and borrowed token value. + # Also, note down the number of stability fee tokens repaid. + stabilityFeeTokensRepaid = sp.local("stabilityFeeTokensRepaid", 0) + remainingStabilityFeeTokens = sp.local("remainingStabilityFeeTokens", 0) + remainingBorrowedTokenBalance = sp.local("remainingBorrowedTokenBalance", 0) + sp.if tokensToRepay < newStabilityFeeTokens: + stabilityFeeTokensRepaid.value = tokensToRepay + remainingStabilityFeeTokens.value = sp.as_nat(newStabilityFeeTokens - tokensToRepay) + remainingBorrowedTokenBalance.value = borrowedTokens + sp.else: + stabilityFeeTokensRepaid.value = newStabilityFeeTokens + remainingStabilityFeeTokens.value = sp.nat(0) + remainingBorrowedTokenBalance.value = sp.as_nat(borrowedTokens - sp.as_nat(tokensToRepay - newStabilityFeeTokens)) + + # Burn and mint tokens in Dev fund. + self.mintTokensToStabilityAndDevFund(stabilityFeeTokensRepaid.value) + self.burnTokens(tokensToRepay, ownerAddress) + + # Inform oven of new state. + self.updateOvenState(ovenAddress, remainingBorrowedTokenBalance.value, remainingStabilityFeeTokens.value, newMinterInterestIndex, isLiquidated, sp.balance) + + # Update internal state + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + # deposit + @sp.entry_point + def deposit(self, param): + sp.set_type(param, OvenApi.DEPOSIT_PARAMETER_TYPE) + + # Verify the sender is a oven. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + + # Verify the balance did not exceed the threshold. + sp.if self.data.ovenMax.is_some(): + sp.verify(sp.balance <= self.data.ovenMax.open_some(), Errors.OVEN_MAXIMUM_EXCEEDED) + + # Destructure input params. + ovenAddress, pair1 = sp.match_pair(param) + ownerAddress, pair2 = sp.match_pair(pair1) + ovenBalance, pair3 = sp.match_pair(pair2) + borrowedTokens, pair4 = sp.match_pair(pair3) + isLiquidated, pair5 = sp.match_pair(pair4) + stabilityFeeTokensInt = sp.fst(pair5) + interestIndex = sp.snd(pair5) + + stabilityFeeTokens = sp.as_nat(stabilityFeeTokensInt) + + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(ownerAddress, sp.TAddress) + sp.set_type(ovenBalance, sp.TNat) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TInt) + + # Calculate new interest indices for the minter and the oven. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Disallow deposit operations on liquidated ovens. + sp.verify(isLiquidated == False, message = Errors.LIQUIDATED) + + # Calculate newly accrued stability fees and determine total fees. + accruedStabilityFeeTokens = self.calculateNewAccruedInterest((interestIndex, (borrowedTokens, (stabilityFeeTokens, (newMinterInterestIndex))))) + newStabilityFeeTokens = stabilityFeeTokens + accruedStabilityFeeTokens + + # Intentional no-op. Pass value back to oven. + self.updateOvenState(ovenAddress, borrowedTokens, newStabilityFeeTokens, newMinterInterestIndex, isLiquidated, sp.balance) + + # Update internal state + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + @sp.entry_point + def withdraw(self, param): + sp.set_type(param, OvenApi.WITHDRAW_PARAMETER_TYPE_ORACLE) + + # Verify the sender is a oven. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + + # Destructure input params. + oraclePrice, pair1 = sp.match_pair(param) + ovenAddress, pair2 = sp.match_pair(pair1) + ownerAddress, pair3 = sp.match_pair(pair2) + ovenBalance, pair4 = sp.match_pair(pair3) + borrowedTokens, pair5 = sp.match_pair(pair4) + isLiquidated, pair6 = sp.match_pair(pair5) + stabilityFeeTokensInt, pair7 = sp.match_pair(pair6) + interestIndex = sp.fst(pair7) + mutezToWithdraw = sp.snd(pair7) + + stabilityFeeTokens = sp.as_nat(stabilityFeeTokensInt) + + sp.set_type(oraclePrice, sp.TNat) + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(ownerAddress, sp.TAddress) + sp.set_type(ovenBalance, sp.TNat) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TInt) + sp.set_type(mutezToWithdraw, sp.TMutez) + + # Calculate new interest indices for the minter and the oven. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Calculate newly accrued stability fees and determine total fees. + accruedStabilityFeeTokens = self.calculateNewAccruedInterest((interestIndex, (borrowedTokens, (stabilityFeeTokens, (newMinterInterestIndex))))) + newStabilityFeeTokens = stabilityFeeTokens + accruedStabilityFeeTokens + + # Verify the oven has not become under-collateralized. + totalOutstandingTokens = borrowedTokens + newStabilityFeeTokens + sp.if totalOutstandingTokens > 0: + withdrawAmount = sp.fst(sp.ediv(mutezToWithdraw, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + newOvenBalance = sp.as_nat(ovenBalance - withdrawAmount) + newCollateralizationPercentage = self.computeCollateralizationPercentage((newOvenBalance, (oraclePrice, totalOutstandingTokens))) + sp.verify(newCollateralizationPercentage >= self.data.collateralizationPercentage, message = Errors.OVEN_UNDER_COLLATERALIZED) + + # Withdraw mutez to the owner. + sp.send(ownerAddress, mutezToWithdraw) + + # Update the oven's state and return the remaining mutez to it. + remainingMutez = sp.mutez(ovenBalance // Constants.MUTEZ_TO_KOLIBRI_CONVERSION) - mutezToWithdraw + self.updateOvenState(ovenAddress, borrowedTokens, newStabilityFeeTokens, newMinterInterestIndex, isLiquidated, remainingMutez) + + # Update internal state + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + # liquidate + @sp.entry_point + def liquidate(self, param): + sp.set_type(param, OvenApi.LIQUIDATE_PARAMETER_TYPE_ORACLE) + + # Verify the sender is a oven. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + + # Destructure input params. + oraclePrice, pair1 = sp.match_pair(param) + ovenAddress, pair2 = sp.match_pair(pair1) + ownerAddress, pair3 = sp.match_pair(pair2) + ovenBalance, pair4 = sp.match_pair(pair3) + borrowedTokens, pair5 = sp.match_pair(pair4) + isLiquidated, pair6 = sp.match_pair(pair5) + stabilityFeeTokensInt, pair7 = sp.match_pair(pair6) + interestIndex = sp.fst(pair7) + liquidatorAddress = sp.snd(pair7) + + stabilityFeeTokens = sp.as_nat(stabilityFeeTokensInt) + + sp.set_type(oraclePrice, sp.TNat) + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(ownerAddress, sp.TAddress) + sp.set_type(ovenBalance, sp.TNat) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TInt) + sp.set_type(liquidatorAddress, sp.TAddress) + + # Calculate new interest indices for the minter and the oven. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + + # Disallow additional liquidate operations on liquidated ovens. + sp.verify(isLiquidated == False, message = Errors.LIQUIDATED) + + # Calculate newly accrued stability fees and determine total fees. + accruedStabilityFeeTokens = self.calculateNewAccruedInterest((interestIndex, (borrowedTokens, (stabilityFeeTokens, (newMinterInterestIndex))))) + newStabilityFeeTokens = stabilityFeeTokens + accruedStabilityFeeTokens + + # Verify collateral percentage. + totalOutstandingTokens = borrowedTokens + newStabilityFeeTokens + collateralizationPercentage = self.computeCollateralizationPercentage((ovenBalance, (oraclePrice, totalOutstandingTokens))) + sp.verify(collateralizationPercentage < self.data.collateralizationPercentage, message = Errors.NOT_UNDER_COLLATERALIZED) + + # Calculate a liquidation fee. + liquidationFee = (totalOutstandingTokens * self.data.liquidationFeePercent) // Constants.PRECISION + + # Burn tokens from the liquidator to pay for the Oven. + self.burnTokens((totalOutstandingTokens + liquidationFee), liquidatorAddress) + + # Mint the extra tokens in the dev fund if they were paid. + self.mintTokensToStabilityAndDevFund(newStabilityFeeTokens + liquidationFee) + + # Send collateral to liquidator. + sp.send(liquidatorAddress, sp.mutez(ovenBalance // Constants.MUTEZ_TO_KOLIBRI_CONVERSION)) + + # Inform oven it is liquidated, clear owed tokens and return no collateral. + self.updateOvenState(ovenAddress, sp.nat(0), sp.nat(0), newMinterInterestIndex, True, sp.mutez(0)) + + # Update internal state + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + ################################################################ + # Governance + # + # Some of these are lumped together to avoid excessive contract + # size. + ################################################################ + + # Params: (stabilityFee, (liquidationFeePercent, (collateralizationPercentage, ovenMax))) + @sp.entry_point + def updateParams(self, newParams): + sp.set_type(newParams, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TOption(sp.TMutez))))) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + + # Compound interest and update internal state. + timeDeltaSeconds = sp.as_nat(sp.now - self.data.lastInterestIndexUpdateTime) + numPeriods = timeDeltaSeconds // Constants.SECONDS_PER_COMPOUND + newMinterInterestIndex = self.compoundWithLinearApproximation((self.data.interestIndex, (self.data.stabilityFee, numPeriods))) + self.data.interestIndex = newMinterInterestIndex + self.data.lastInterestIndexUpdateTime = self.data.lastInterestIndexUpdateTime.add_seconds(sp.to_int(numPeriods * Constants.SECONDS_PER_COMPOUND)) + + # Update to new parameters. + newStabilityFee, pair1 = sp.match_pair(newParams) + newLiquidationFeePercent, pair2 = sp.match_pair(pair1) + newCollateralizationPercentage, newOvenMax = sp.match_pair(pair2) + + self.data.stabilityFee = newStabilityFee + self.data.liquidationFeePercent = newLiquidationFeePercent + self.data.collateralizationPercentage = newCollateralizationPercentage + self.data.ovenMax = newOvenMax + + # Params: (governor (token, (ovenProxy, (stabilityFund, devFund)))) + @sp.entry_point + def updateContracts(self, newParams): + sp.set_type(newParams, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TAddress))))) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + + newGovernorContractAddress, pair1 = sp.match_pair(newParams) + newTokenContractAddress, pair2 = sp.match_pair(pair1) + newOvenProxyContractAddress, pair3 = sp.match_pair(pair2) + newStabilityFundContractAddress, newDeveloperFundContractAddress = sp.match_pair(pair3) + + self.data.governorContractAddress = newGovernorContractAddress + self.data.tokenContractAddress = newTokenContractAddress + self.data.ovenProxyContractAddress = newOvenProxyContractAddress + self.data.stabilityFundContractAddress = newStabilityFundContractAddress + self.data.developerFundContractAddress = newDeveloperFundContractAddress + + ################################################################ + # Helpers + ################################################################ + + # Mint tokens to a stability fund. + # + # This function does *NOT* burn tokens - the caller must do this. This is an efficiency gain because normally + # we would burn tokens for collateral + stability fees. + def mintTokensToStabilityAndDevFund(self, tokensToMint): + sp.set_type(tokensToMint, sp.TNat) + + # Determine proportion of tokens minted to dev fund. + tokensForDevFund = (tokensToMint * self.data.stabilityDevFundSplit) // Constants.PRECISION + tokensForStabilityFund = sp.as_nat(tokensToMint - tokensForDevFund) + + # Mint tokens + self.mintTokens(tokensForDevFund, self.data.developerFundContractAddress) + self.mintTokens(tokensForStabilityFund, self.data.stabilityFundContractAddress) + + def burnTokens(self, tokensToBurn, address): + sp.set_type(tokensToBurn, sp.TNat) + sp.set_type(address, sp.TAddress) + + tokenContractParam = sp.record(address= address, value= tokensToBurn) + contractHandle = sp.contract( + sp.TRecord(address = sp.TAddress, value = sp.TNat), + self.data.tokenContractAddress, + "burn" + ).open_some() + sp.transfer(tokenContractParam, sp.mutez(0), contractHandle) + + def mintTokens(self, tokensToMint, address): + sp.set_type(tokensToMint, sp.TNat) + sp.set_type(address, sp.TAddress) + + tokenContractParam = sp.record(address= address, value= tokensToMint) + contractHandle = sp.contract( + sp.TRecord(address = sp.TAddress, value = sp.TNat), + self.data.tokenContractAddress, + "mint" + ).open_some() + sp.transfer(tokenContractParam, sp.mutez(0), contractHandle) + + # Calculate newly accrued stability fees with the given input. + @sp.global_lambda + def calculateNewAccruedInterest(params): + sp.set_type(params, sp.TPair(sp.TInt, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TNat)))) + + ovenInterestIndex = sp.as_nat(sp.fst(params)) + borrowedTokens = sp.fst(sp.snd(params)) + stabilityFeeTokens = sp.fst(sp.snd(sp.snd(params))) + minterInterestIndex = sp.snd(sp.snd(sp.snd(params))) + + ratio = sp.fst(sp.ediv((minterInterestIndex * Constants.PRECISION), ovenInterestIndex).open_some()) + totalPrinciple = borrowedTokens + stabilityFeeTokens + newTotalTokens = sp.fst(sp.ediv((ratio * totalPrinciple), Constants.PRECISION).open_some()) + newTokensAccruedAsFee = sp.as_nat(newTotalTokens - totalPrinciple) + sp.result(newTokensAccruedAsFee) + + # Compound interest via a linear approximation. + @sp.global_lambda + def compoundWithLinearApproximation(params): + sp.set_type(params, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TNat))) + + initialValue = sp.fst(params) + stabilityFee = sp.fst(sp.snd(params)) + numPeriods = sp.snd(sp.snd(params)) + + sp.result((initialValue * (Constants.PRECISION + (numPeriods * stabilityFee))) // Constants.PRECISION) + + # Compute the collateralization percentage from the given inputs + # Output is in the form of 200_000_000 (= 200%) + @sp.global_lambda + def computeCollateralizationPercentage(params): + sp.set_type(params, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TNat))) + + ovenBalance = sp.fst(params) + xtzPrice = sp.fst(sp.snd(params)) + borrowedTokens = sp.snd(sp.snd(params)) + + # Compute collateral value. + collateralValue = ovenBalance * xtzPrice // Constants.PRECISION + ratio = (collateralValue * Constants.PRECISION) // (borrowedTokens) + sp.result(ratio * 100) + + def updateOvenState(self, ovenAddress, borrowedTokens, stabilityFeeTokens, interestIndex, isLiquidated, sendAmount): + sp.set_type(ovenAddress, sp.TAddress) + sp.set_type(borrowedTokens, sp.TNat) + sp.set_type(stabilityFeeTokens, sp.TNat) + sp.set_type(interestIndex, sp.TNat) + sp.set_type(isLiquidated, sp.TBool) + sp.set_type(sendAmount, sp.TMutez) + + # Inform oven of new state. + ovenContractParam = (ovenAddress, (borrowedTokens, (sp.to_int(stabilityFeeTokens), (sp.to_int(interestIndex), isLiquidated)))) + + ovenHandle = sp.contract( + OvenApi.UPDATE_STATE_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.UPDATE_STATE_ENTRY_POINT_NAME + ).open_some() + + sp.transfer(ovenContractParam, sendAmount, ovenHandle) + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") + DevFund = sp.import_script_from_url("file:dev-fund.py") + DummyContract = sp.import_script_from_url("file:test-helpers/dummy-contract.py") + MockOvenProxy = sp.import_script_from_url("file:test-helpers/mock-oven-proxy.py") + StabilityFund = sp.import_script_from_url("file:stability-fund.py") + Token = sp.import_script_from_url("file:token.py") + + ################################################################ + # Helpers + ################################################################ + + # A Tester flass that wraps a lambda function to allow for unit testing. + # See: https://smartpy.io/releases/20201220-f9f4ad18bd6ec2293f22b8c8812fefbde46d6b7d/ide?template=test_global_lambda.py + class Tester(sp.Contract): + def __init__(self, lambdaFunc): + self.lambdaFunc = sp.inline_result(lambdaFunc.f) + self.init(lambdaResult = sp.none) + + @sp.entry_point + def test(self, params): + self.data.lambdaResult = sp.some(self.lambdaFunc(params)) + + @sp.entry_point + def check(self, params, result): + sp.verify(self.lambdaFunc(params) == result) + + ################################################################ + # calculateNewAccruedInterest + ################################################################ + + @sp.add_test(name="calculateNewAccruedInterest") + def test(): + scenario = sp.test_scenario() + minter = MinterContract() + scenario += minter + + tester = Tester(minter.calculateNewAccruedInterest) + scenario += tester + + scenario += tester.check( + params = (sp.to_int(1 * Constants.PRECISION), (100 * Constants.PRECISION, (0 * Constants.PRECISION, 1100000000000000000))), + result = 10 * Constants.PRECISION + ) + scenario += tester.check( + params = (sp.int(1100000000000000000), (100 * Constants.PRECISION, (10 * Constants.PRECISION, 1210000000000000000))), + result = 11 * Constants.PRECISION + ) + scenario += tester.check( + params = (sp.to_int(1 * Constants.PRECISION), (100 * Constants.PRECISION, (0 * Constants.PRECISION, 1210000000000000000))), + result = 21 * Constants.PRECISION + ) + + scenario += tester.check( + params = (sp.int(1100000000000000000), (100 * Constants.PRECISION, (0 * Constants.PRECISION, 1210000000000000000))), + result = 10 * Constants.PRECISION + ) + scenario += tester.check( + params = (sp.int(1210000000000000000), (100 * Constants.PRECISION, (10 * Constants.PRECISION, 1331000000000000000))), + result = 11 * Constants.PRECISION + ) + scenario += tester.check( + params = (sp.int(1100000000000000000), (100 * Constants.PRECISION, (0 * Constants.PRECISION, 1331000000000000000))), + result = 21 * Constants.PRECISION + ) + + ################################################################ + # compoundWithLinearApproximation + ################################################################ + + @sp.add_test(name="compoundWithLinearApproximation") + def test(): + scenario = sp.test_scenario() + minter = MinterContract() + scenario += minter + + tester = Tester(minter.compoundWithLinearApproximation) + scenario += tester + + # Two periods back to back + scenario += tester.check( + params = (1 * Constants.PRECISION, (100000000000000000, 1)), + result = sp.nat(1100000000000000000) + ) + scenario += tester.check( + params = (1100000000000000000, (100000000000000000, 1)), + result = 1210000000000000000 + ) + + # Two periods in one update + scenario += tester.check( + params = (1 * Constants.PRECISION, (100000000000000000, 2)), + result = 1200000000000000000 + ) + + ############################################################### + # Liquidate + ############################################################### + + @sp.add_test(name="liquidate - successfully compounds interest and accrues fees") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND dummy contracts to act as the dev and stability funds. + stabilityFund = DummyContract.DummyContract() + devFund = DummyContract.DummyContract() + scenario += stabilityFund + scenario += devFund + + # AND a Minter contract + liquidationFeePercent = sp.nat(80000000000000000) # 8% + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + minter = MinterContract( + liquidationFeePercent = liquidationFeePercent, + ovenProxyContractAddress = ovenProxy.address, + stabilityFundContractAddress = stabilityFund.address, + developerFundContractAddress = devFund.address, + tokenContractAddress = token.address, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = Constants.PRECISION, + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = governorAddress + ) + + # AND a dummy contract that acts as the liquidator. + liquidator = DummyContract.DummyContract() + scenario += liquidator + + # AND the liquidator has $1000 of tokens. + ovenOwnerTokens = 1000 * Constants.PRECISION + mintForOvenOwnerParam = sp.record(address = liquidator.address, value = ovenOwnerTokens) + scenario += token.mint(mintForOvenOwnerParam).run( + sender = minter.address + ) + + # WHEN liquidate is called on an undercollateralized oven with $100 of tokens outstanding + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + + xtzPrice = Constants.PRECISION # 1 XTZ / $1 + + ovenBorrowedTokens = 90 * Constants.PRECISION # $90 kUSD + stabilityFeeTokens = sp.to_int(10 * Constants.PRECISION) # 10 kUSD + + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + isLiquidated = False + + interestIndex = sp.to_int(Constants.PRECISION) + + liquidatorAddress = liquidator.address + + param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + + # AND one period has elapsed + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.liquidate(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = now, + ) + + # THEN an updated interest index is sent to the oven + scenario.verify(ovenProxy.data.updateState_interestIndex == sp.to_int(minter.data.interestIndex)) + + # AND all stability fees on the oven are repaid. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.int(0)) + + # AND the minter compounded interest. + scenario.verify(minter.data.interestIndex == 1100000000000000000) + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + + # AND the liquidator received the collateral in the oven. + scenario.verify(liquidator.balance == ovenBalanceMutez) + + # AND the liquidator is debited the correct number of tokens. + expectedNewlyAccruedStabilityFees = 10 * Constants.PRECISION + outstandingTokens = sp.as_nat(stabilityFeeTokens) + ovenBorrowedTokens + expectedNewlyAccruedStabilityFees + liquidationFee = (outstandingTokens * liquidationFeePercent) // Constants.PRECISION + totalTokensPaid = outstandingTokens + liquidationFee + scenario.verify(token.data.balances[liquidator.address].balance == sp.as_nat(ovenOwnerTokens - totalTokensPaid)) + + # AND the stability and dev funds receive a split of the liquidation fee and stability tokens + tokensReclaimedForFunds = liquidationFee + stabilityFeeTokens + expectedNewlyAccruedStabilityFees + expectedDevFundTokens = (tokensReclaimedForFunds * stabilityDevFundSplit) // Constants.PRECISION + expectedStabilityFundTokens = sp.as_nat(tokensReclaimedForFunds - expectedDevFundTokens) + + # AND the oven is marked as liquidated with values cleared correctly. + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == 0) + scenario.verify(ovenProxy.data.updateState_isLiquidated == True) + + @sp.add_test(name="liquidate - successfully liquidates undercollateralized oven") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND dummy contracts to act as the dev and stability funds. + stabilityFund = DummyContract.DummyContract() + devFund = DummyContract.DummyContract() + scenario += stabilityFund + scenario += devFund + + # AND a Minter contract + liquidationFeePercent = sp.nat(80000000000000000) # 8% + stabilityDevFundSplit = sp.nat(100000000000000000) # 10% + minter = MinterContract( + liquidationFeePercent = liquidationFeePercent, + ovenProxyContractAddress = ovenProxy.address, + stabilityFundContractAddress = stabilityFund.address, + developerFundContractAddress = devFund.address, + tokenContractAddress = token.address + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = governorAddress + ) + + # AND a dummy contract that acts as the liquidator. + liquidator = DummyContract.DummyContract() + scenario += liquidator + + # AND the liquidator has $1000 of tokens. + ovenOwnerTokens = 1000 * Constants.PRECISION + mintForOvenOwnerParam = sp.record(address = liquidator.address, value = ovenOwnerTokens) + scenario += token.mint(mintForOvenOwnerParam).run( + sender = minter.address + ) + + # WHEN liquidate is called on an undercollateralized oven. + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + + xtzPrice = Constants.PRECISION # 1 XTZ / $1 + + ovenBorrowedTokens = 2 * Constants.PRECISION # $2 kUSD + + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + isLiquidated = False + + stabilityFeeTokens = sp.to_int(Constants.PRECISION) + interestIndex = sp.to_int(Constants.PRECISION) + + liquidatorAddress = liquidator.address + + param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + scenario += minter.liquidate(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the liquidator received the collateral in the oven. + scenario.verify(liquidator.balance == ovenBalanceMutez) + + # AND the liquidator is debited the correct number of tokens. + outstandingTokens = sp.as_nat(stabilityFeeTokens) + ovenBorrowedTokens + liquidationFee = (outstandingTokens * liquidationFeePercent) // Constants.PRECISION + totalTokensPaid = outstandingTokens + liquidationFee + scenario.verify(token.data.balances[liquidator.address].balance == sp.as_nat(ovenOwnerTokens - totalTokensPaid)) + + # AND the stability and dev funds receive a split of the liquidation fee and stability tokens + tokensReclaimedForFunds = liquidationFee + stabilityFeeTokens + expectedDevFundTokens = (tokensReclaimedForFunds * stabilityDevFundSplit) // Constants.PRECISION + expectedStabilityFundTokens = sp.as_nat(tokensReclaimedForFunds - expectedDevFundTokens) + + # AND the oven is marked as liquidated with values cleared correctly. + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == 0) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == 0) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + scenario.verify(ovenProxy.data.updateState_isLiquidated == True) + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538 + # @sp.add_test(name="liquidate - fails when liquidator has too few tokens") + # def test(): + # scenario = sp.test_scenario() + + # # GIVEN an OvenProxy contract + # ovenProxy = MockOvenProxy.MockOvenProxyContract() + # scenario += ovenProxy + + # # AND a Token contract. + # governorAddress = Addresses.GOVERNOR_ADDRESS + # token = Token.FA12( + # admin = governorAddress + # ) + # scenario += token + + # # AND a Minter contract + # minter = MinterContract( + # ovenProxyContractAddress = ovenProxy.address, + # tokenContractAddress = token.address + # ) + # scenario += minter + + # # AND the Minter is the Token administrator + # scenario += token.setAdministrator(minter.address).run( + # sender = governorAddress + # ) + + # # AND a dummy contract that acts as the liquidator. + # liquidator = DummyContract.DummyContract() + # scenario += liquidator + + # # AND the liquidator has $1 of tokens. + # ovenOwnerTokens = 1 * Constants.PRECISION + # mintForOvenOwnerParam = sp.record(address = liquidator.address, value = ovenOwnerTokens) + # scenario += token.mint(mintForOvenOwnerParam).run( + # sender = minter.address + # ) + + # # WHEN liquidating an undecollateralized requires more tokens than the liquidator has. + # ovenBalance = Constants.PRECISION # 1 XTZ + # ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + + # xtzPrice = Constants.PRECISION # 1 XTZ / $1 + + # ovenBorrowedTokens = 2 * Constants.PRECISION # $2 kUSD + + # ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + # ovenAddress = Addresses.OVEN_ADDRESS + # isLiquidated = False + + # stabilityFeeTokens = sp.to_int(Constants.PRECISION) + # interestIndex = sp.to_int(Constants.PRECISION) + + # liquidatorAddress = liquidator.address + + # # THEN the call fails. + # param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + # scenario += minter.liquidate(param).run( + # sender = ovenProxy.address, + # amount = ovenBalanceMutez, + # now = sp.timestamp_from_utc_now(), + # valid = False + # ) + + @sp.add_test(name="liquidate - fails if oven is properly collateralized") + def test(): + scenario = sp.test_scenario() + + # GIVEN an Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN liquidate is called on an oven that exactly meets the collateralization ratios + ovenBalance = 2 * Constants.PRECISION # 2 XTZ + ovenBalanceMutez = sp.mutez(2000000) # 2 XTZ + xtzPrice = Constants.PRECISION # 1 XTZ / $1 + ovenBorrowedTokens = 1 * Constants.PRECISION # $1 kUSD + + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + + stabilityFeeTokens = sp.to_int(0) + interestIndex = sp.to_int(Constants.PRECISION) + + isLiquidated = False + + param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + + # THEN the call fails. + scenario += minter.liquidate(param).run( + sender = ovenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="liquidate - fails if oven is already liquidated") + def test(): + scenario = sp.test_scenario() + + # GIVEN an Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN liquidate is called on an undercollateralized oven which is already liquidated + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + + xtzPrice = Constants.PRECISION # 1 XTZ / $1 + + ovenBorrowedTokens = 2 * Constants.PRECISION # $2 kUSD + + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + + stabilityFeeTokens = sp.to_int(Constants.PRECISION) + interestIndex = sp.to_int(Constants.PRECISION) + + isLiquidated = True + + param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + + # THEN the call fails. + scenario += minter.liquidate(param).run( + sender = ovenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="liquidate - fails if not called by ovenProxy") + def test(): + scenario = sp.test_scenario() + + # GIVEN an Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN liquidate is called on an undercollateralized oven by someone other than the oven proxy + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + + xtzPrice = Constants.PRECISION # 1 XTZ / $1 + + ovenBorrowedTokens = 2 * Constants.PRECISION # $2 kUSD + + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + + stabilityFeeTokens = sp.to_int(Constants.PRECISION) + interestIndex = sp.to_int(Constants.PRECISION) + + isLiquidated = False + + param = (xtzPrice, (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress)))))))) + + # THEN the call fails. + notOvenProxy = Addresses.NULL_ADDRESS + scenario += minter.liquidate(param).run( + sender = notOvenProxy, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + ############################################################### + # Repay + ############################################################### + + @sp.add_test(name="repay - succeeds and compoounds interest and stability fees correctly") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = Constants.PRECISION, + ) + scenario += minter + + # WHEN repay is called with valid inputs + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenAddress = Addresses.OVEN_ADDRESS + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + ovenBorrowedTokens = 100 * Constants.PRECISION # $100 kUSD + isLiquidated = False + stabilityFeeTokens = sp.int(0) + interestIndex = sp.to_int(Constants.PRECISION) + tokensToRepay = sp.nat(1) + param = (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.repay(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = now, + ) + + # THEN an updated interest index and stability fee is sent to the oven. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == ((10 * Constants.PRECISION) - tokensToRepay)) + scenario.verify(ovenProxy.data.updateState_interestIndex == sp.to_int(minter.data.interestIndex)) + + # AND the minter compounded interest. + scenario.verify(minter.data.interestIndex == 1100000000000000000) + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + + @sp.add_test(name="repay - repays amount greater than stability fees") + def test(): + scenario = sp.test_scenario() + + # GIVEN a governor + governorAddress = Addresses.GOVERNOR_ADDRESS + + # AND an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Oven owner + ovenOwner = Addresses.OVEN_OWNER_ADDRESS + + # AND a Token contract. + interimTokenAdministrator = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = interimTokenAdministrator + ) + scenario += token + + # AND a developer fund contract. + developerFund = DevFund.DevFundContract( + governorContractAddress = governorAddress, + ) + scenario += developerFund + + # AND a stability fund contract + stabilityFund = StabilityFund.StabilityFundContract( + governorContractAddress = governorAddress, + ) + scenario += stabilityFund + + # AND a Minter contract + stabilityDevFundSplit = sp.nat(250000000000000000) # 25% + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + governorContractAddress = governorAddress, + tokenContractAddress = token.address, + stabilityFundContractAddress = stabilityFund.address, + developerFundContractAddress = developerFund.address, + stabilityFee = sp.nat(0), + stabilityDevFundSplit = stabilityDevFundSplit + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = interimTokenAdministrator + ) + + # AND the oven owner has 100 tokens. + ovenOwnerTokens = sp.nat(100) + mintForOvenOwnerParam = sp.record(address = ovenOwner, value = ovenOwnerTokens) + scenario += token.mint(mintForOvenOwnerParam).run( + sender = minter.address + ) + + # WHEN repay is called with an amount greater than stability fees + ovenAddress = Addresses.OVEN_ADDRESS + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + ovenBorrowedTokens = sp.nat(12) + isLiquidated = False + stabilityFeeTokens = sp.int(4) + interestIndex = sp.to_int(Constants.PRECISION) + tokensToRepay = sp.nat(8) + param = (ovenAddress, (ovenOwner, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + scenario += minter.repay(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the stability fees are set to zero. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.int(0)) + + # AND the borrowed tokens is reduced by the remainder. + expectedBorrowedTokens = sp.as_nat(ovenBorrowedTokens - sp.as_nat(tokensToRepay - sp.as_nat(stabilityFeeTokens))) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == expectedBorrowedTokens) + + # AND the oven owner was debited the amount of tokens to repay. + scenario.verify(token.data.balances[ovenOwner].balance == sp.as_nat(ovenOwnerTokens - tokensToRepay)) + + # AND the stability fund and dev fund received the proportion of tokens from the stability fees paid. + expectedDeveloperFundBalance = (sp.as_nat(stabilityFeeTokens) * stabilityDevFundSplit) // Constants.PRECISION + scenario.verify(token.data.balances[developerFund.address].balance == expectedDeveloperFundBalance) + scenario.verify(token.data.balances[stabilityFund.address].balance == sp.as_nat(sp.as_nat(stabilityFeeTokens) - expectedDeveloperFundBalance)) + + # AND the other values are passed back to the the oven proxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + + # AND the oven proxy received the balance of the oven. + scenario.verify(ovenProxy.balance == ovenBalanceMutez) + + @sp.add_test(name="repay - repays amount less than stability fees") + def test(): + scenario = sp.test_scenario() + + # GIVEN a governor + governorAddress = Addresses.GOVERNOR_ADDRESS + + # AND an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Oven owner + ovenOwner = Addresses.OVEN_OWNER_ADDRESS + + # AND a Token contract. + interimTokenAdministrator = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = interimTokenAdministrator + ) + scenario += token + + # AND a developer fund contract. + developerFund = DevFund.DevFundContract( + governorContractAddress = governorAddress, + ) + scenario += developerFund + + # AND a stability fund contract + stabilityFund = StabilityFund.StabilityFundContract( + governorContractAddress = governorAddress, + ) + scenario += stabilityFund + + # AND a Minter contract + stabilityDevFundSplit = sp.nat(250000000000000000) # 25% + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + governorContractAddress = governorAddress, + tokenContractAddress = token.address, + stabilityFundContractAddress = stabilityFund.address, + developerFundContractAddress = developerFund.address, + stabilityFee = sp.nat(0), + stabilityDevFundSplit = stabilityDevFundSplit + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = interimTokenAdministrator + ) + + # AND the oven owner has 100 tokens. + ovenOwnerTokens = sp.nat(100) + mintForOvenOwnerParam = sp.record(address = ovenOwner, value = ovenOwnerTokens) + scenario += token.mint(mintForOvenOwnerParam).run( + sender = minter.address + ) + + # WHEN repay is called with an amount less than stability fees + ovenAddress = Addresses.OVEN_ADDRESS + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + ovenBorrowedTokens = sp.nat(12) + isLiquidated = False + stabilityFeeTokens = sp.int(5) + interestIndex = sp.to_int(Constants.PRECISION) + tokensToRepay = sp.nat(4) + param = (ovenAddress, (ovenOwner, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + scenario += minter.repay(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the stability fees are reduced by the amount to repay and the borrowed tokens are the same. + expectedStabilityFeeTokens = stabilityFeeTokens - sp.to_int(tokensToRepay) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == expectedStabilityFeeTokens) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == ovenBorrowedTokens) + + # AND the oven owner was debited the amount of tokens to repay. + scenario.verify(token.data.balances[ovenOwner].balance == sp.as_nat(ovenOwnerTokens - tokensToRepay)) + + # AND the stability fund and dev fund received the proportion of tokens from the stability fees paid. + expectedDeveloperFundBalance = (tokensToRepay * stabilityDevFundSplit) // Constants.PRECISION + scenario.verify(token.data.balances[developerFund.address].balance == expectedDeveloperFundBalance) + scenario.verify(token.data.balances[stabilityFund.address].balance == sp.as_nat(tokensToRepay - expectedDeveloperFundBalance)) + + # AND the other values are passed back to the the oven proxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + + # AND the oven proxy received the balance of the oven. + scenario.verify(ovenProxy.balance == ovenBalanceMutez) + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538 + # @sp.add_test(name="repay - repays more tokens than owned") + # def test(): + # scenario = sp.test_scenario() + + # # GIVEN a governor, oven proxy and oven owner address. + # governorAddress = Addresses.GOVERNOR_ADDRESS + # ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + # ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + + # # AND a Token contract. + # token = Token.FA12( + # admin = governorAddress + # ) + # scenario += token + + # # AND a Minter contract + # minter = MinterContract( + # ovenProxyContractAddress = ovenProxyAddress, + # governorContractAddress = governorAddress, + # tokenContractAddress = token.address, + # stabilityFee = sp.nat(0), + # ) + # scenario += minter + + # # AND the Minter is the Token administrator + # scenario += token.setAdministrator(minter.address).run( + # sender = governorAddress + # ) + + # # AND the oven owner has 1 tokens. + # ovenOwnerTokens = sp.nat(1) + # mintForOvenOwnerParam = sp.record(address = ovenOwnerAddress, value = ovenOwnerTokens) + # scenario += token.mint(mintForOvenOwnerParam).run( + # sender = minter.address + # ) + + # # WHEN repay is called with for an amount greater than the amount owned THEN the call fails. + # ovenAddress = Addresses.OVEN_ADDRESS + # ovenBalance = Constants.PRECISION # 1 XTZ + # ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + # ovenBorrowedTokens = sp.nat(12) + # isLiquidated = False + # stabilityFeeTokens = sp.int(5) + # interestIndex = sp.to_int(Constants.PRECISION) + + # tokensToRepay = 2 * ovenOwnerTokens + + # param = (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + # scenario += minter.repay(param).run( + # sender = ovenProxyAddress, + # amount = ovenBalanceMutez, + # now = sp.timestamp_from_utc_now(), + # valid = False + # ) + + @sp.add_test(name="repay - repays greater amount than owed") + def test(): + scenario = sp.test_scenario() + + # GIVEN a governor, oven proxy and oven owner address. + governorAddress = Addresses.GOVERNOR_ADDRESS + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + + # AND a Token contract. + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + governorContractAddress = governorAddress, + tokenContractAddress = token.address, + stabilityFee = sp.nat(0), + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = governorAddress + ) + + # AND the oven owner has 100 tokens. + ovenOwnerTokens = sp.nat(100) + mintForOvenOwnerParam = sp.record(address = ovenOwnerAddress, value = ovenOwnerTokens) + scenario += token.mint(mintForOvenOwnerParam).run( + sender = minter.address + ) + + # WHEN repay is called with for an amount greater than is owed THEN the call fails. + ovenAddress = Addresses.OVEN_ADDRESS + ovenBalance = Constants.PRECISION # 1 XTZ + ovenBalanceMutez = sp.mutez(1000000) # 1 XTZ + ovenBorrowedTokens = sp.nat(12) + isLiquidated = False + stabilityFeeTokens = sp.int(5) + interestIndex = sp.to_int(Constants.PRECISION) + + tokensToRepay = 2 * (sp.as_nat(stabilityFeeTokens) + ovenBorrowedTokens) + param = (ovenAddress, (ovenOwnerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + scenario += minter.repay(param).run( + sender = ovenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="repay - fails if oven is liquidated") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address + ) + scenario += minter + + # WHEN repay is called from a liquidated oven THEN the call fails + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenBalance = sp.nat(1) + ovenBorrowedTokens = sp.nat(2) + isLiquidated = True + stabilityFeeTokens = sp.int(3) + interestIndex = sp.to_int(Constants.PRECISION) + tokensToRepay = sp.nat(1) + param = (ovenAddress, (ownerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + scenario += minter.repay(param).run( + sender = ovenProxy.address, + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + @sp.add_test(name="repay - fails if not called by oven proxy") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN repay is called by someone other than the oven proxy THEN the call fails + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + ovenBalance = sp.nat(1) + ovenBorrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.to_int(Constants.PRECISION) + tokensToRepay = sp.nat(1) + param = (ovenAddress, (ownerAddress, (ovenBalance, (ovenBorrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + notOvenProxyAddress = Addresses.NULL_ADDRESS + scenario += minter.repay(param).run( + sender = notOvenProxyAddress, + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + ############################################################### + # Borrow + ############################################################### + + @sp.add_test(name="borrow - succeeds and accrues stability fees") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract. + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract. + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = Constants.PRECISION, + ) + scenario += minter + + # WHEN borrow is called with valid inputs + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + isLiquidated = False + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 300 * Constants.PRECISION # 300 XTZ / $300 + ovenBalanceMutez = sp.mutez(300000000) # 300 XTZ / $300 + + borrowedTokens = 100 * Constants.PRECISION # $100 kUSD + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = Constants.PRECISION + + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.borrow(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = now, + ) + + # THEN an updated interest index and stability fee is sent to the oven. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.to_int(10 * Constants.PRECISION)) + scenario.verify(ovenProxy.data.updateState_interestIndex == sp.to_int(minter.data.interestIndex)) + + # AND the minter compounded interest. + scenario.verify(minter.data.interestIndex == 1100000000000000000) + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + + @sp.add_test(name="borrow - succeeds and mints tokens") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + tokenContractAddress = token.address + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = governorAddress + ) + + # WHEN borrow is called with valid inputs representing some tokens which are already borrowed. + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + isLiquidated = False + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 4 * Constants.PRECISION # 4 XTZ / $4 + ovenBalanceMutez = sp.mutez(2000000) # 4 XTZ / $4 + + borrowedTokens = Constants.PRECISION # $1 kUSD + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = Constants.PRECISION # $1 kUSD + + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + scenario += minter.borrow(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN tokens are minted to the owner + scenario.verify(token.data.balances[ownerAddress].balance == tokensToBorrow) + + # AND the rest of the params are passed back to the oven proxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == (borrowedTokens + tokensToBorrow)) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == stabilityFeeTokens) + + # AND the remaining balance is passed back to the oven proxy + scenario.verify(ovenProxy.balance == ovenBalanceMutez) + + @sp.add_test(name="borrow - succeeds and mints tokens when zero tokens are outstanding") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Token contract. + governorAddress = Addresses.GOVERNOR_ADDRESS + token = Token.FA12( + admin = governorAddress + ) + scenario += token + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + tokenContractAddress = token.address + ) + scenario += minter + + # AND the Minter is the Token administrator + scenario += token.setAdministrator(minter.address).run( + sender = governorAddress + ) + + # WHEN borrow is called with valid inputs and no tokens borrowed + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + isLiquidated = False + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 2 * Constants.PRECISION # 2 XTZ / $2 + ovenBalanceMutez = sp.mutez(2000000) # 2 XTZ / $2 + + borrowedTokens = sp.nat(0) + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = Constants.PRECISION + + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + scenario += minter.borrow(param).run( + sender = ovenProxy.address, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN tokens are minted to the owner + scenario.verify(token.data.balances[ownerAddress].balance == tokensToBorrow) + + # AND the rest of the params are passed back to the oven proxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == tokensToBorrow) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == stabilityFeeTokens) + + # AND the remaining balance is passed back to the oven proxy + scenario.verify(ovenProxy.balance == ovenBalanceMutez) + + @sp.add_test(name="borrow - Fails if oven is undercollateralized") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN borrow is called with an amount that will undercollateralize the oven. + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + isLiquidated = False + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 2 * Constants.PRECISION # 2 XTZ / $2 + ovenBalanceMutez = sp.mutez(2000000) # 2 XTZ / $2 + + borrowedTokens = sp.nat(0) + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = ovenBalance + + # THEN the call fails. + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + scenario += minter.borrow(param).run( + sender = ovenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="borrow - fails if oven is liquidated") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN borrow is called from a liquidated Oven. + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + + isLiquidated = True + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 2 * Constants.PRECISION # 2 XTZ / $2 + ovenBalanceMutez = sp.mutez(2000000) # 2 XTZ / $2 + + borrowedTokens = sp.nat(0) + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = Constants.PRECISION + + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + + # THEN the call fails + scenario += minter.borrow(param).run( + sender = ovenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="borrow - fails when not called by ovenProxy") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress, + ) + scenario += minter + + # WHEN borrow is called by someone other than the OvenProxy + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + + isLiquidated = True + + xtzPrice = Constants.PRECISION # $1 / XTZ + ovenBalance = 2 * Constants.PRECISION # 2 XTZ / $2 + ovenBalanceMutez = sp.mutez(2000000) # 2 XTZ / $2 + + borrowedTokens = sp.nat(0) + + interestIndex = sp.to_int(Constants.PRECISION) + stabilityFeeTokens = sp.int(0) + + tokensToBorrow = Constants.PRECISION + + param = (xtzPrice, (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow)))))))) + + notOvenProxyAddress = Addresses.NULL_ADDRESS + + # THEN the call fails + scenario += minter.borrow(param).run( + sender = notOvenProxyAddress, + amount = ovenBalanceMutez, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + ################################################################ + # Withdraw + ################################################################ + + @sp.add_test(name="withdraw - succeeds and compounds interest and stability fees correctly") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = Constants.PRECISION, + ) + scenario += minter + + # AND given inputs that represent a properly collateralized oven at a 200% collateralization ratio + xtzPrice = 2 * Constants.PRECISION # $2 / XTZ + borrowedTokens = 100 * Constants.PRECISION # $100 kUSD + lockedCollateralMutez = sp.mutez(2100000000) # 210XTZ / $210 + lockedCollateral = 210 * Constants.PRECISION # 219 XTZ / $210 + + # WHEN withdraw is called with an amount that does not under collateralize the oven + amountToWithdrawMutez = sp.mutez(1) + ovenAddress = Addresses.OVEN_ADDRESS + ovenOwnerAddress = Addresses.OVEN_OWNER_ADDRESS + isLiquidated = False + stabilityFeeTokens = sp.int(0) + interestIndex = sp.to_int(Constants.PRECISION) + param = ( + xtzPrice, ( + ovenAddress, ( + ovenOwnerAddress, ( + lockedCollateral, ( + borrowedTokens, ( + isLiquidated, ( + stabilityFeeTokens, ( + interestIndex, amountToWithdrawMutez + ) + ) + ) + ) + ) + ) + ) + ) + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.withdraw(param).run( + sender = ovenProxy.address, + amount = lockedCollateralMutez, + now = now, + ) + + # THEN an updated interest index and stability fee is sent to the oven. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.to_int(10 * Constants.PRECISION)) + scenario.verify(ovenProxy.data.updateState_interestIndex == sp.to_int(minter.data.interestIndex)) + + # AND the minter compounded interest. + scenario.verify(minter.data.interestIndex == 1100000000000000000) + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + + @sp.add_test(name="withdraw - Able to withdraw") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address + ) + scenario += minter + + # AND a dummy contract that acts as the Oven owner + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # AND given inputs that represent a properly collateralized oven at a 200% collateralization ratio + xtzPrice = 1 * Constants.PRECISION # $1 / XTZ + borrowedTokens = 10 * Constants.PRECISION # $10 kUSD + lockedCollateralMutez = sp.mutez(21000000) # 21XTZ / $21 + lockedCollateral = 21 * Constants.PRECISION # 21 XTZ / $21 + + # WHEN withdraw is called with an amount that does not under collateralize the oven + amountToWithdrawMutez = sp.mutez(1000000) # 1 XTZ / $1 + ovenAddress = Addresses.OVEN_ADDRESS + ovenOwnerAddress = dummyContract.address + isLiquidated = False + param = ( + xtzPrice, ( + ovenAddress, ( + ovenOwnerAddress, ( + lockedCollateral, ( + borrowedTokens, ( + isLiquidated, ( + sp.int(0), ( + sp.to_int(Constants.PRECISION), amountToWithdrawMutez + ) + ) + ) + ) + ) + ) + ) + ) + scenario += minter.withdraw(param).run( + sender = ovenProxy.address, + amount = lockedCollateralMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the oven owner receives the withdrawal + scenario.verify(dummyContract.balance == amountToWithdrawMutez) + + # AND the OvenProxy received the remainder of the collateral with correct values + scenario.verify(ovenProxy.balance == (lockedCollateralMutez - amountToWithdrawMutez)) + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + + @sp.add_test(name="withdraw - Able to withdraw with zero borrowed tokens") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy contract + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND a Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address + ) + scenario += minter + + # AND a dummy contract that acts as the Oven owner + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # AND given inputs that represent a properly collateralized oven with zero tokens borrowed + xtzPrice = 1 * Constants.PRECISION # $1 / XTZ + borrowedTokens = sp.nat(0) # $0 kUSD + lockedCollateralMutez = sp.mutez(21000000) # 21XTZ / $21 + lockedCollateral = 21 * Constants.PRECISION # 21 XTZ / $21 + + # WHEN withdraw is called + amountToWithdrawMutez = sp.mutez(1000000) # 1 XTZ / $1 + ovenAddress = Addresses.OVEN_ADDRESS + ovenOwnerAddress = dummyContract.address + isLiquidated = False + param = ( + xtzPrice, ( + ovenAddress, ( + ovenOwnerAddress, ( + lockedCollateral, ( + borrowedTokens, ( + isLiquidated, ( + sp.int(0), ( + sp.to_int(Constants.PRECISION), amountToWithdrawMutez + ) + ) + ) + ) + ) + ) + ) + ) + scenario += minter.withdraw(param).run( + sender = ovenProxy.address, + amount = lockedCollateralMutez, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the oven owner receives the withdrawal + scenario.verify(dummyContract.balance == amountToWithdrawMutez) + + # AND the OvenProxy received the remainder of the collateral with correct values + scenario.verify(ovenProxy.balance == (lockedCollateralMutez - amountToWithdrawMutez)) + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxy.data.updateState_isLiquidated == isLiquidated) + + @sp.add_test(name="withdraw - fails when withdraw will undercollateralize oven") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # AND given inputs that represent a properly collateralized oven at a 200% collateralization ratio + xtzPrice = 1 * Constants.PRECISION # $1 / XTZ + borrowedTokens = 10 * Constants.PRECISION # $10 kUSD + lockedCollateralMutez = sp.mutez(21000000) # 21XTZ / $21 + lockedCollateral = 21 * Constants.PRECISION # 21 XTZ / $21 + + # WHEN withdraw is called with an amount that under collateralizes the oven THEN the call fails + amountToWithdrawMutez = sp.mutez(10000000) # 10 XTZ / $10 + param = ( + xtzPrice, ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + lockedCollateral, ( + borrowedTokens, ( + False, ( + sp.int(4), ( + sp.int(5), amountToWithdrawMutez + ) + ) + ) + ) + ) + ) + ) + ) + scenario += minter.withdraw(param).run( + sender = ovenProxyAddress, + valid = False, + amount = lockedCollateralMutez, + now = sp.timestamp_from_utc_now(), + ) + + @sp.add_test(name="withdraw - fails when withdraw is greater than amount") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN withdraw is called from an with a greater amount than collateral is available THEN the call fails + amountMutez = sp.mutez(10) + amount = 10 * Constants.PRECISION + withdrawAmountMutez = sp.mutez(20) + param = ( + sp.nat(1), ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + amount, ( + sp.nat(3), ( + False, ( + sp.int(4), ( + sp.int(5), withdrawAmountMutez + ) + ) + ) + ) + ) + ) + ) + ) + scenario += minter.withdraw(param).run( + sender = ovenProxyAddress, + valid = False, + amount = amountMutez, + now = sp.timestamp_from_utc_now(), + ) + + @sp.add_test(name="withdraw - succeeds even if when oven is liquidated") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN withdraw is called from an with a liquidated oven THEN the call fails. + isLiquidated = True + param = ( + Constants.PRECISION, ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ( + Constants.PRECISION, ( + sp.nat(0), ( + isLiquidated, ( + sp.int(0), ( + sp.to_int(Constants.PRECISION), sp.mutez(1) + ) + ) + ) + ) + ) + ) + ) + ) + scenario += minter.withdraw(param).run( + sender = ovenProxyAddress, + now = sp.timestamp_from_utc_now(), + amount = sp.mutez(1000000) + ) + + @sp.add_test(name="withdraw - fails when not called by oven proxy") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN withdraw is called from an address other than the OvenProxy THEN the call fails + notOvenProxyAddress = Addresses.NULL_ADDRESS + param = (sp.nat(1), (notOvenProxyAddress, (notOvenProxyAddress, (sp.nat(2), (sp.nat(3), (False, (sp.int(4), (sp.int(5), sp.mutez(6))))))))) + scenario += minter.withdraw(param).run( + sender = notOvenProxyAddress, + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + ################################################################ + # Deposit + ################################################################ + + @sp.add_test(name="deposit - succeeds and compoounds interest and stability fees correctly") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = Constants.PRECISION, + ) + scenario += minter + + # WHEN deposit is called + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + stabilityFeeTokens = sp.int(0) + interestIndex = sp.to_int(Constants.PRECISION) + borrowedTokens = 100 * Constants.PRECISION # $100 kUSD + balance = sp.mutez(1000000) # 1 XTZ + balanceNat = Constants.PRECISION + param = ( + ovenAddress, ( + ownerAddress, ( + balanceNat, ( + borrowedTokens, ( + False, ( + stabilityFeeTokens, + interestIndex + ) + ) + ) + ) + ) + ) + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.deposit(param).run( + amount = balance, + sender = ovenProxy.address, + now = now + ) + + # THEN an updated interest index and stability fee is sent to the oven. + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.to_int(10 * Constants.PRECISION)) + scenario.verify(ovenProxy.data.updateState_interestIndex == sp.to_int(minter.data.interestIndex)) + + # AND the minter compounded interest. + scenario.verify(minter.data.interestIndex == 1100000000000000000) + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + + @sp.add_test(name="deposit - succeeds") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Minter contract + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address + ) + scenario += minter + + # WHEN deposit is called + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + balance = sp.mutez(1) + balanceNat = sp.nat(1) + borrowedTokens = sp.nat(2) + stabilityFeeTokens = sp.int(0) + interestIndex = sp.int(1000000000000000000) + param = ( + ovenAddress, ( + ownerAddress, ( + balanceNat, ( + borrowedTokens, ( + False, ( + stabilityFeeTokens, + interestIndex + ) + ) + ) + ) + ) + ) + scenario += minter.deposit(param).run( + amount = balance, + sender = ovenProxy.address, + now = sp.timestamp_from_utc_now(), + ) + + # THEN input parameters are propagated to the OvenProxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxy.data.updateState_isLiquidated == False) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.int(0)) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + + # AND the mutez balance is sent to the oven proxy + scenario.verify(ovenProxy.balance == balance) + + @sp.add_test(name="deposit - succeeds with no oven limit") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Minter contract with no oven max. + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + ovenMax = sp.none + ) + scenario += minter + + # WHEN deposit is called + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + balance = sp.mutez(100000001) # 100.000001 XTZ + balanceNat = sp.nat(100000001000000000000) # 100.000001 XTZ + borrowedTokens = sp.nat(2) + stabilityFeeTokens = sp.int(0) + interestIndex = sp.int(1000000000000000000) + param = ( + ovenAddress, ( + ownerAddress, ( + balanceNat, ( + borrowedTokens, ( + False, ( + stabilityFeeTokens, + interestIndex + ) + ) + ) + ) + ) + ) + scenario += minter.deposit(param).run( + amount = balance, + sender = ovenProxy.address, + now = sp.timestamp_from_utc_now(), + ) + + # THEN input parameters are propagated to the OvenProxy + scenario.verify(ovenProxy.data.updateState_ovenAddress == ovenAddress) + scenario.verify(ovenProxy.data.updateState_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxy.data.updateState_isLiquidated == False) + scenario.verify(ovenProxy.data.updateState_stabilityFeeTokens == sp.int(0)) + scenario.verify(ovenProxy.data.updateState_interestIndex == interestIndex) + + # AND the mutez balance is sent to the oven proxy + scenario.verify(ovenProxy.balance == balance) + + @sp.add_test(name="deposit - fails if over oven max") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenProxy + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an Minter contract with an oven maximum + ovenMax = sp.tez(100) + minter = MinterContract( + ovenProxyContractAddress = ovenProxy.address, + ovenMax = sp.some(ovenMax) + ) + scenario += minter + + # WHEN deposit is called with an amount greater than the maximum + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + balance = ovenMax + sp.mutez(1) # 100.000001 XTZ + balanceNat = sp.nat(100000001000000000000) # 100.000001 XTZ + borrowedTokens = sp.nat(2) + stabilityFeeTokens = sp.int(0) + interestIndex = sp.int(1000000000000000000) + param = ( + ovenAddress, ( + ownerAddress, ( + balanceNat, ( + borrowedTokens, ( + False, ( + stabilityFeeTokens, + interestIndex + ) + ) + ) + ) + ) + ) + + # THEN the call fails. + scenario += minter.deposit(param).run( + amount = balance, + sender = ovenProxy.address, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="deposit - fails when oven is liquidated") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN deposit is called from an with a liquidated oven THEN the call fails. + isLiquidated = True + param = (sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), (sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), (sp.nat(1), (sp.nat(2), (isLiquidated, (sp.int(3), (sp.int(4)))))))) + scenario += minter.deposit(param).run( + sender = ovenProxyAddress, + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + @sp.add_test(name="deposit - fails when not called by oven proxy") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + ovenProxyAddress = Addresses.OVEN_PROXY_ADDRESS + minter = MinterContract( + ovenProxyContractAddress = ovenProxyAddress + ) + scenario += minter + + # WHEN deposit is called from an address other than the OvenProxy THEN the call fails + notOvenProxyAddress = Addresses.NULL_ADDRESS + param = (notOvenProxyAddress, (notOvenProxyAddress, (sp.nat(1), (sp.nat(2), (False, (sp.int(3), (sp.int(4)))))))) + scenario += minter.deposit(param).run( + sender = notOvenProxyAddress, + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + ################################################################ + # getInterestIndex + ################################################################ + + @sp.add_test(name="getInterestIndex - compounds interest and calls back") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + initialInterestIndex = Constants.PRECISION + stabilityFee = Constants.PRECISION + initialTime = sp.timestamp(0) + minter = MinterContract( + interestIndex = initialInterestIndex, + stabilityFee = stabilityFee, + lastInterestIndexUpdateTime = initialTime + ) + scenario += minter + + # AND a dummy contract to receive the callback. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN getInterestIndex is called + callback = sp.contract(sp.TNat, dummyContract.address, "natCallback").open_some() + scenario += minter.getInterestIndex(callback).run( + now = sp.timestamp_from_utc_now(), + ) + + # THEN interest is compounded in minter. + scenario.verify(minter.data.interestIndex > initialInterestIndex) + scenario.verify(minter.data.lastInterestIndexUpdateTime > initialTime) + + # AND the callback returned the correct value. + scenario.verify(dummyContract.data.natValue == minter.data.interestIndex) + + @sp.add_test(name="getInterestIndex - fails with amount") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + minter = MinterContract() + scenario += minter + + # AND a dummy contract to receive the callback. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN getInterestIndex is called with an amount THEN the call fails. + callback = sp.contract(sp.TNat, dummyContract.address, "natCallback").open_some() + scenario += minter.getInterestIndex(callback).run( + amount = sp.mutez(1), + valid = False, + now = sp.timestamp_from_utc_now(), + ) + + ################################################################ + # updateContracts + ################################################################ + + @sp.add_test(name="updateContracts - updates contracts") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + governorAddress = Addresses.GOVERNOR_ADDRESS + minter = MinterContract( + governorContractAddress = governorAddress + ) + scenario += minter + + # WHEN updateContracts is called by the governor + newGovernorContractAddress = DummyContract.DummyContract().address + newTokenContractAddress = DummyContract.DummyContract().address + newOvenProxyContractAddress = DummyContract.DummyContract().address + newStabilityFundContractAddress = DummyContract.DummyContract().address + newdeveloperFundContractAddress = DummyContract.DummyContract().address + newContracts = (newGovernorContractAddress, (newTokenContractAddress, (newOvenProxyContractAddress, (newStabilityFundContractAddress, newdeveloperFundContractAddress)))) + scenario += minter.updateContracts(newContracts).run( + sender = governorAddress, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the contracts are updated. + scenario.verify(minter.data.governorContractAddress == newGovernorContractAddress) + scenario.verify(minter.data.tokenContractAddress == newTokenContractAddress) + scenario.verify(minter.data.ovenProxyContractAddress == newOvenProxyContractAddress) + scenario.verify(minter.data.stabilityFundContractAddress == newStabilityFundContractAddress) + scenario.verify(minter.data.developerFundContractAddress == newdeveloperFundContractAddress) + + @sp.add_test(name="updateContracts - fails if not called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + governorAddress = Addresses.GOVERNOR_ADDRESS + minter = MinterContract( + governorContractAddress = governorAddress + ) + scenario += minter + + # WHEN updateContracts is called by someone other than the governor THEN the request fails + newGovernorContractAddress = DummyContract.DummyContract().address + newTokenContractAddress = DummyContract.DummyContract().address + newOvenProxyContractAddress = DummyContract.DummyContract().address + newStabilityFundContractAddress = DummyContract.DummyContract().address + newdeveloperFundContractAddress = DummyContract.DummyContract().address + newContracts = (newGovernorContractAddress, (newTokenContractAddress, (newOvenProxyContractAddress, (newStabilityFundContractAddress, newdeveloperFundContractAddress)))) + notGovernor = Addresses.NULL_ADDRESS + scenario += minter.updateContracts(newContracts).run( + sender = notGovernor, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + ################################################################ + # updateParams + ################################################################ + + @sp.add_test(name="updateParams - compounds interest") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract with an interest index + governorAddress = Addresses.GOVERNOR_ADDRESS + minter = MinterContract( + governorContractAddress = governorAddress, + stabilityFee = 100000000000000000, + lastInterestIndexUpdateTime = sp.timestamp(0), + interestIndex = 1100000000000000000, + ) + scenario += minter + + # WHEN updateParams is called by the governor + newStabilityFee = sp.nat(1) + newLiquidationFeePercent = sp.nat(2) + newCollateralizationPercentage = sp.nat(3) + newOvenMax = sp.some(sp.tez(4)) + newParams = (newStabilityFee, (newLiquidationFeePercent, (newCollateralizationPercentage, newOvenMax))) + now = sp.timestamp(Constants.SECONDS_PER_COMPOUND) + scenario += minter.updateParams(newParams).run( + sender = governorAddress, + now = now + ) + + # THEN the the interest is compounded. + scenario.verify(minter.data.lastInterestIndexUpdateTime == now) + scenario.verify(minter.data.interestIndex == 1210000000000000000) + + @sp.add_test(name="updateParams - updates parameters") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + governorAddress = Addresses.GOVERNOR_ADDRESS + minter = MinterContract( + governorContractAddress = governorAddress + ) + scenario += minter + + # WHEN updateParams is called by the governor + newStabilityFee = sp.nat(1) + newLiquidationFeePercent = sp.nat(2) + newCollateralizationPercentage = sp.nat(3) + newOvenMax = sp.some(sp.tez(123)) + newParams = (newStabilityFee, (newLiquidationFeePercent, (newCollateralizationPercentage, newOvenMax))) + scenario += minter.updateParams(newParams).run( + sender = governorAddress, + now = sp.timestamp_from_utc_now(), + ) + + # THEN the parameters are updated. + scenario.verify(minter.data.stabilityFee == newStabilityFee) + scenario.verify(minter.data.liquidationFeePercent == newLiquidationFeePercent) + scenario.verify(minter.data.collateralizationPercentage == newCollateralizationPercentage) + scenario.verify(minter.data.ovenMax.open_some() == newOvenMax.open_some()) + + @sp.add_test(name="updateParams - fails if not called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN a Minter contract + governorAddress = Addresses.GOVERNOR_ADDRESS + minter = MinterContract( + governorContractAddress = governorAddress + ) + scenario += minter + + # WHEN updateParams is called by someone other than the governor THEN the request fails + newStabilityFee = sp.nat(1) + newLiquidationFeePercent = sp.nat(2) + newCollateralizationPercentage = sp.nat(3) + newOvenMax = sp.some(sp.tez(123)) + newParams = (newStabilityFee, (newLiquidationFeePercent, (newCollateralizationPercentage, newOvenMax))) + notGovernor = Addresses.NULL_ADDRESS + scenario += minter.updateParams(newParams).run( + sender = notGovernor, + now = sp.timestamp_from_utc_now(), + valid = False + ) diff --git a/smart_contracts/minter.tz b/smart_contracts/minter.tz new file mode 100644 index 00000000..fc623e9d --- /dev/null +++ b/smart_contracts/minter.tz @@ -0,0 +1,3807 @@ +parameter (or (or (or (pair %borrow nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (pair %deposit address (pair address (pair nat (pair nat (pair bool (pair int int))))))) (or (contract %getInterestIndex nat) (pair %liquidate nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))))) (or (or (pair %repay address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) (pair %updateContracts address (pair address (pair address (pair address address))))) (or (pair %updateParams nat (pair nat (pair nat (option mutez)))) (pair %withdraw nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))); +storage (pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))))); +code + { + LAMBDA + (pair int (pair nat (pair nat nat))) + nat + { + DUP; # pair int (pair nat (pair nat nat)) : pair int (pair nat (pair nat nat)) + CDDAR; # nat : pair int (pair nat (pair nat nat)) + SWAP; # pair int (pair nat (pair nat nat)) : nat + DUP; # pair int (pair nat (pair nat nat)) : pair int (pair nat (pair nat nat)) : nat + DUG 2; # pair int (pair nat (pair nat nat)) : nat : pair int (pair nat (pair nat nat)) + CDAR; # nat : nat : pair int (pair nat (pair nat nat)) + ADD; # nat : pair int (pair nat (pair nat nat)) + PUSH nat 1000000000000000000; # nat : nat : pair int (pair nat (pair nat nat)) + DIG 2; # pair int (pair nat (pair nat nat)) : nat : nat + DUP; # pair int (pair nat (pair nat nat)) : pair int (pair nat (pair nat nat)) : nat : nat + CDDAR; # nat : pair int (pair nat (pair nat nat)) : nat : nat + SWAP; # pair int (pair nat (pair nat nat)) : nat : nat : nat + DUP; # pair int (pair nat (pair nat nat)) : pair int (pair nat (pair nat nat)) : nat : nat : nat + DUG 4; # pair int (pair nat (pair nat nat)) : nat : nat : nat : pair int (pair nat (pair nat nat)) + CDAR; # nat : nat : nat : nat : pair int (pair nat (pair nat nat)) + ADD; # nat : nat : nat : pair int (pair nat (pair nat nat)) + DIG 3; # pair int (pair nat (pair nat nat)) : nat : nat : nat + DUP; # pair int (pair nat (pair nat nat)) : pair int (pair nat (pair nat nat)) : nat : nat : nat + DUG 4; # pair int (pair nat (pair nat nat)) : nat : nat : nat : pair int (pair nat (pair nat nat)) + CAR; # int : nat : nat : nat : pair int (pair nat (pair nat nat)) + ISNAT; # option nat : nat : nat : nat : pair int (pair nat (pair nat nat)) + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : pair int (pair nat (pair nat nat)) + FAILWITH; # FAILED + }; # @some : nat : nat : nat : pair int (pair nat (pair nat nat)) + PUSH nat 1000000000000000000; # nat : @some : nat : nat : nat : pair int (pair nat (pair nat nat)) + DIG 5; # pair int (pair nat (pair nat nat)) : nat : @some : nat : nat : nat + CDDDR; # nat : nat : @some : nat : nat : nat + MUL; # nat : @some : nat : nat : nat + EDIV; # option (pair nat nat) : nat : nat : nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat + CAR; # nat : nat : nat : nat + MUL; # nat : nat : nat + EDIV; # option (pair nat nat) : nat + IF_SOME + {} + { + UNIT; # unit : nat + FAILWITH; # FAILED + }; # @some : nat + CAR; # nat : nat + SUB; # int + ISNAT; # option nat + IF_SOME + {} + { + UNIT; # unit + FAILWITH; # FAILED + }; # @some + }; # lambda (pair int (pair nat (pair nat nat))) nat : pair @parameter @storage + SWAP; # pair @parameter @storage : lambda (pair int (pair nat (pair nat nat))) nat + LAMBDA + (pair nat (pair nat nat)) + nat + { + PUSH nat 1000000000000000000; # nat : pair nat (pair nat nat) + SWAP; # pair nat (pair nat nat) : nat + DUP; # pair nat (pair nat nat) : pair nat (pair nat nat) : nat + CDAR; # nat : pair nat (pair nat nat) : nat + SWAP; # pair nat (pair nat nat) : nat : nat + DUP; # pair nat (pair nat nat) : pair nat (pair nat nat) : nat : nat + DUG 3; # pair nat (pair nat nat) : nat : nat : pair nat (pair nat nat) + CDDR; # nat : nat : nat : pair nat (pair nat nat) + MUL; # nat : nat : pair nat (pair nat nat) + PUSH nat 1000000000000000000; # nat : nat : nat : pair nat (pair nat nat) + ADD; # nat : nat : pair nat (pair nat nat) + DIG 2; # pair nat (pair nat nat) : nat : nat + CAR; # nat : nat : nat + MUL; # nat : nat + EDIV; # option (pair nat nat) + IF_SOME + { + CAR; # nat + } + { + UNIT; # unit + FAILWITH; # FAILED + }; # nat + }; # lambda (pair nat (pair nat nat)) nat : pair @parameter @storage : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair @parameter @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + LAMBDA + (pair nat (pair nat nat)) + nat + { + DUP; # pair nat (pair nat nat) : pair nat (pair nat nat) + CDDR; # nat : pair nat (pair nat nat) + PUSH nat 100; # nat : nat : pair nat (pair nat nat) + SWAP; # nat : nat : pair nat (pair nat nat) + PUSH nat 1000000000000000000; # nat : nat : nat : pair nat (pair nat nat) + DUP; # nat : nat : nat : nat : pair nat (pair nat nat) + DIG 4; # pair nat (pair nat nat) : nat : nat : nat : nat + DUP; # pair nat (pair nat nat) : pair nat (pair nat nat) : nat : nat : nat : nat + CDAR; # nat : pair nat (pair nat nat) : nat : nat : nat : nat + SWAP; # pair nat (pair nat nat) : nat : nat : nat : nat : nat + CAR; # nat : nat : nat : nat : nat : nat + MUL; # nat : nat : nat : nat : nat + EDIV; # option (pair nat nat) : nat : nat : nat + IF_SOME + { + CAR; # nat : nat : nat : nat + } + { + UNIT; # unit : nat : nat : nat + FAILWITH; # FAILED + }; # nat : nat : nat : nat + MUL; # nat : nat : nat + EDIV; # option (pair nat nat) : nat + IF_SOME + { + CAR; # nat : nat + } + { + UNIT; # unit : nat + FAILWITH; # FAILED + }; # nat : nat + MUL; # nat + }; # lambda (pair nat (pair nat nat)) nat : pair @parameter @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair @parameter @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair @parameter @storage : pair @parameter @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # @storage : pair @parameter @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair @parameter @storage : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # @parameter : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 2; # int : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%borrow : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%borrow : @parameter%borrow : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : @parameter%borrow : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @parameter%borrow : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # bool : pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair bool (pair int (pair int nat)) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int nat) : pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int (pair int nat) : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH bool False; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # bool : bool : pair int nat : int : pair int (pair int nat) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # bool : bool : bool : pair int nat : int : pair int (pair int nat) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # bool : bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 16; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 0; # nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUG 20; # lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # int : nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # int : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair int nat : nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # pair int nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + GT; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 15; # @storage : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAAAR; # nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 17; # lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 18; # lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUG 21; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair int nat : nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # pair int nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 16; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 17; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + GE; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # pair int (pair int nat) : pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair bool (pair int (pair int nat)) : pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair bool (pair int (pair int nat))) : pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # nat : pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair int nat : int : bool : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair int nat : int : bool : nat : address : address : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # nat : pair int nat : int : bool : nat : address : address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @parameter%borrow : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # lambda (pair nat (pair nat nat)) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + PUSH int 11; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + DIG 2; # pair int (pair int nat) : pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair bool (pair int (pair int nat)) : pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair bool (pair int (pair int nat))) : pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # nat : pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair int nat : int : bool : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))) : pair int nat : int : bool : nat : address : address : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : nat : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # nat : pair int nat : int : bool : nat : address : address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @parameter%borrow : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @parameter%borrow : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # lambda (pair nat (pair nat nat)) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + }; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NIL operation; # list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # @storage : list operation : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # @storage : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDDDR; # address : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %mint (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 0; # mutez : @some : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair int nat : mutez : @some : list operation : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : mutez : @some : list operation : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # pair int nat : mutez : @some : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : mutez : @some : list operation : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # address : nat : mutez : @some : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR %address %value; # pair (address %address) (nat %value) : mutez : @some : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + TRANSFER_TOKENS; # operation : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONS; # list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @storage : list operation : pair int nat : int : bool : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int nat : int : bool : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # @storage : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + BALANCE; # mutez : @some : list operation : pair int nat : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + INT; # int : bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage + DUG 11; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 7; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : pair int bool : mutez : @some : list operation : pair int nat : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # int : nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : pair int bool : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair int bool) : mutez : @some : list operation : pair int nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # pair int nat : pair int (pair int bool) : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # nat : pair int (pair int bool) : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # nat : nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair int (pair int bool)) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # address : pair nat (pair int (pair int bool)) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair address (pair nat (pair int (pair int bool))) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + SWAP; # @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 2; # int : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDAAR; # option mutez : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + DROP; # @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%deposit : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDAAR; # option mutez : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + BALANCE; # mutez : @some : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + LE; # bool : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 21; # int : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + {}; # @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%deposit : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%deposit : @parameter%deposit : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : @parameter%deposit : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @parameter%deposit : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int int)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int int)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair nat (pair nat (pair bool (pair int int)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair nat (pair nat (pair bool (pair int int)))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int int))) : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int int))) : pair nat (pair nat (pair bool (pair int int))) : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair nat (pair bool (pair int int))) : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair nat (pair bool (pair int int))) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int int)) : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int int)) : pair nat (pair bool (pair int int)) : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair bool (pair int int)) : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair bool (pair int int)) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int int) : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int int) : pair bool (pair int int) : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # bool : pair bool (pair int int) : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair bool (pair int int) : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH bool False; # bool : pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # bool : bool : pair int int : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # bool : bool : bool : pair int int : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # bool : bool : pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # pair bool (pair int int) : pair int int : bool : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair nat (pair bool (pair int int)) : pair int int : bool : nat : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # nat : pair int int : bool : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair nat (pair nat (pair bool (pair int int))) : pair int int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # address : pair int int : bool : nat : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair address (pair nat (pair nat (pair bool (pair int int)))) : pair int int : bool : nat : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # @parameter%deposit : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + PUSH int 16; # int : pair int int : bool : pair bool (pair int int) : nat : pair nat (pair bool (pair int int)) : nat : pair nat (pair nat (pair bool (pair int int))) : address : pair address (pair nat (pair nat (pair bool (pair int int)))) : address : @parameter%deposit : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NIL operation; # list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # @storage : list operation : pair int int : bool : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int int : bool : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # @storage : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + BALANCE; # mutez : @some : list operation : pair int int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + INT; # int : bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 9; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage + DUG 10; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # pair int int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int int : pair int int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 7; # pair int int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # pair int int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int int : pair int int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 7; # pair int int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : pair int bool : mutez : @some : list operation : pair int int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # pair int int : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair int bool) : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair int (pair int bool)) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # address : pair nat (pair int (pair int bool)) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair address (pair nat (pair int (pair int bool))) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + IF_LEFT + { + PUSH mutez 0; # mutez : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + AMOUNT; # mutez : mutez : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # lambda (pair nat (pair nat nat)) nat : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # lambda (pair int (pair nat (pair nat nat))) nat : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat + DROP; # @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat + } + { + PUSH int 15; # int : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat + NIL operation; # list operation : @parameter%getInterestIndex : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 0; # mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage + DUG 5; # lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : lambda (pair nat (pair nat nat)) nat + DUG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : mutez : @parameter%getInterestIndex : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + SWAP; # @storage : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 2; # int : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%liquidate : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%liquidate : @parameter%liquidate : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : @parameter%liquidate : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @parameter%liquidate : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int address)))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int address)))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair nat (pair bool (pair int (pair int address)))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int address))) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int address))) : pair nat (pair bool (pair int (pair int address))) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair bool (pair int (pair int address))) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int address)) : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int address)) : pair bool (pair int (pair int address)) : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # bool : pair bool (pair int (pair int address)) : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair bool (pair int (pair int address)) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int address) : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int address) : pair int (pair int address) : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair int (pair int address) : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int (pair int address) : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH bool False; # bool : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # bool : bool : pair int address : int : pair int (pair int address) : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # bool : bool : bool : pair int address : int : pair int (pair int address) : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # bool : bool : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 16; # int : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAAAR; # nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 17; # lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 18; # lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUG 21; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 16; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 17; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + LT; # bool : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # pair int (pair int address) : pair int address : int : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # bool : pair int address : int : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair bool (pair int (pair int address)) : pair int address : int : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair nat (pair bool (pair int (pair int address))) : pair int address : int : nat : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair nat (pair bool (pair int (pair int address)))) : pair int address : int : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # address : pair int address : int : nat : nat : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : pair int address : int : nat : nat : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : pair int address : int : nat : nat : address : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # nat : pair int address : int : nat : nat : address : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # @parameter%liquidate : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # lambda (pair nat (pair nat nat)) nat : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + PUSH int 10; # int : pair int address : int : pair int (pair int address) : bool : pair bool (pair int (pair int address)) : nat : pair nat (pair bool (pair int (pair int address))) : nat : pair nat (pair nat (pair bool (pair int (pair int address)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : nat : @parameter%liquidate : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NIL operation; # list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # @storage : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDDDR; # address : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %burn (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 0; # mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDDR; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 13; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 13; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # int : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # int : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 12; # lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 13; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # int : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # int : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair int address : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # pair int address : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # address : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR %address %value; # pair (address %address) (nat %value) : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + TRANSFER_TOKENS; # operation : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONS; # list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # @storage : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDDDR; # address : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %mint (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 0; # mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADDR; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDDR; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 15; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 14; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAADAR; # address : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR %address %value; # pair (address %address) (nat %value) : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + TRANSFER_TOKENS; # operation : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONS; # list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 7; # @storage : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDDDR; # address : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %mint (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 0; # mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADDR; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # @storage : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDDR; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 15; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 15; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # int : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 14; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000000000; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDDR; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 14; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 13; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 14; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 14; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 15; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # int : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 12; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 12; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage + DUG 13; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 13; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 14; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 13; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 14; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 9; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int address : pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # pair int address : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : nat : nat : mutez : @some : list operation : pair int address : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # int : nat : nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # @storage : @some : mutez : @some : list operation : pair int address : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : @some : mutez : @some : list operation : pair int address : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 8; # @storage : @some : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDDAR; # address : @some : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR %address %value; # pair (address %address) (@some %value) : mutez : @some : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : pair int address : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair int address : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # address : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT unit; # option (contract unit) : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 1; # mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 1000000000000; # nat : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # nat : nat : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + MUL; # mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + UNIT; # unit : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 2; # @storage : list operation : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : address : lambda (pair nat (pair nat nat)) nat + DUG 3; # @storage : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CDADAR; # address : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 0; # mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH bool True; # bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage + DUG 7; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUG 8; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUG 8; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : lambda (pair nat (pair nat nat)) nat + DUG 8; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 0; # nat : pair int bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : pair int bool : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 0; # nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair int (pair int bool)) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # address : pair nat (pair int (pair int bool)) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair address (pair nat (pair int (pair int bool))) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%repay : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%repay : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 2; # int : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%repay : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%repay : @parameter%repay : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : @parameter%repay : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @parameter%repay : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair bool (pair int (pair int nat))) : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # bool : pair bool (pair int (pair int nat)) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair bool (pair int (pair int nat)) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int nat) : pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair int (pair int nat) : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int (pair int nat) : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH bool False; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # bool : bool : pair int nat : int : pair int (pair int nat) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # bool : bool : bool : pair int nat : int : pair int (pair int nat) : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # bool : bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # pair int (pair int nat) : pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair bool (pair int (pair int nat)) : pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair bool (pair int (pair int nat))) : pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # nat : pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair nat (pair bool (pair int (pair int nat)))) : pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : pair int nat : int : bool : nat : address : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # @parameter%repay : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # lambda (pair nat (pair nat nat)) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + PUSH int 16; # int : pair int nat : int : pair int (pair int nat) : bool : pair bool (pair int (pair int nat)) : nat : pair nat (pair bool (pair int (pair int nat))) : nat : pair nat (pair nat (pair bool (pair int (pair int nat)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))) : address : @parameter%repay : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 9; # lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # int : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # int : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # pair int nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + LT; # bool : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DUP; # pair int nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # pair int nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage + DUG 11; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 6; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 5; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # int : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + DIG 8; # lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 9; # lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # int : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # int : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 0; # nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage + DUG 11; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 6; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int nat : pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 5; # pair int nat : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : nat : nat : pair int nat : int : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # int : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 3; # pair int nat : nat : nat : nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair int nat : pair int nat : nat : nat : nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 4; # pair int nat : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # nat : nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : nat : pair int nat : bool : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # nat : @some : nat : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + }; # nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + NIL operation; # list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 9; # @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDDDR; # address : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT %mint (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 0; # mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 1000000000000000000; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDADDR; # nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # nat : nat : nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : nat : nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # nat : nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + MUL; # nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CAADAR; # address : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR %address %value; # pair (address %address) (nat %value) : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 9; # @storage : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDDDR; # address : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT %mint (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 0; # mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 1000000000000000000; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDADDR; # nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # nat : nat : nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : nat : nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # nat : nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + MUL; # nat : nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : mutez : @some : list operation : nat : @some : nat : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # nat : nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # @storage : @some : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : @some : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 11; # @storage : @some : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDDAR; # address : @some : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR %address %value; # pair (address %address) (@some %value) : mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # @storage : list operation : nat : @some : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : nat : @some : pair int nat : bool : address : address : lambda (pair nat (pair nat nat)) nat + DUG 8; # @storage : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDDDR; # address : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT %burn (pair (address %address) (nat %value)); # option (contract (pair (address %address) (nat %value))) : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH mutez 0; # mutez : @some : list operation : nat : @some : pair int nat : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # pair int nat : mutez : @some : list operation : nat : @some : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # nat : mutez : @some : list operation : nat : @some : bool : address : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # address : nat : mutez : @some : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR %address %value; # pair (address %address) (nat %value) : mutez : @some : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # @storage : list operation : nat : @some : bool : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : nat : @some : bool : address : lambda (pair nat (pair nat nat)) nat + DUG 6; # @storage : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + CDADAR; # address : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + BALANCE; # mutez : @some : list operation : nat : @some : bool : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage + DUG 9; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 9; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 9; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : lambda (pair nat (pair nat nat)) nat + DUG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int bool : mutez : @some : list operation : nat : @some : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # @some : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair int bool) : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair int (pair int bool)) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # address : pair nat (pair int (pair int bool)) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair address (pair nat (pair int (pair int bool))) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + SWAP; # @storage : @parameter%updateContracts : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%updateContracts : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAADDR; # address : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # lambda (pair nat (pair nat nat)) nat : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # lambda (pair nat (pair nat nat)) nat : @parameter%updateContracts : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # @parameter%updateContracts : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # lambda (pair int (pair nat (pair nat nat))) nat : @parameter%updateContracts : @storage + DROP; # @parameter%updateContracts : @storage + } + { + PUSH int 4; # int : @parameter%updateContracts : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%updateContracts : @storage + DUP; # @parameter%updateContracts : @parameter%updateContracts : @storage + CAR; # address : @parameter%updateContracts : @storage + SWAP; # @parameter%updateContracts : address : @storage + CDR; # pair address (pair address (pair address address)) : address : @storage + DUP; # pair address (pair address (pair address address)) : pair address (pair address (pair address address)) : address : @storage + CAR; # address : pair address (pair address (pair address address)) : address : @storage + SWAP; # pair address (pair address (pair address address)) : address : address : @storage + CDR; # pair address (pair address address) : address : address : @storage + DUP; # pair address (pair address address) : pair address (pair address address) : address : address : @storage + CAR; # address : pair address (pair address address) : address : address : @storage + SWAP; # pair address (pair address address) : address : address : address : @storage + CDR; # pair address address : address : address : address : @storage + DUP; # pair address address : pair address address : address : address : address : @storage + CAR; # address : pair address address : address : address : address : @storage + SWAP; # pair address address : address : address : address : address : @storage + CDR; # address : address : address : address : address : @storage + DIG 5; # @storage : address : address : address : address : address + DUP; # @storage : @storage : address : address : address : address : address + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : address : address : address : address : address + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + CDR; # pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + DUP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + CAR; # nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + CDAR; # address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address : address + DIG 8; # address : address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + SWAP; # address : address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + PAIR; # pair address address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + SWAP; # nat : pair address address : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + PAIR; # pair nat (pair address address) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + PAIR; # pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : address : address : address : address + SWAP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + DUP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + CAR; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + SWAP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + CDR; # pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + DUP; # pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + CAR; # nat : pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + SWAP; # pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : nat : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + CDAR; # address : nat : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address : address + DIG 7; # address : address : nat : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + SWAP; # address : address : nat : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + PAIR; # pair address address : nat : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + SWAP; # nat : pair address address : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + PAIR; # pair nat (pair address address) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + SWAP; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + DUP; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + CAR; # option mutez : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + SWAP; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : option mutez : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + CDDR; # nat : option mutez : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address : address + DIG 6; # address : nat : option mutez : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + PAIR; # pair address nat : option mutez : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + SWAP; # option mutez : pair address nat : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + PAIR; # pair (option mutez) (pair address nat) : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + SWAP; # pair nat (pair address address) : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + DUP; # pair nat (pair address address) : pair nat (pair address address) : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + CAR; # nat : pair nat (pair address address) : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + SWAP; # pair nat (pair address address) : nat : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + CDDR; # address : nat : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address : address + DIG 5; # address : address : nat : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + PAIR; # pair address address : nat : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + SWAP; # nat : pair address address : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + PAIR; # pair nat (pair address address) : pair (option mutez) (pair address nat) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + SWAP; # pair (option mutez) (pair address nat) : pair nat (pair address address) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + PAIR; # pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : address + SWAP; # pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + DUP; # pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + CDR; # pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + SWAP; # pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + CAR; # pair nat (pair address address) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + DUP; # pair nat (pair address address) : pair nat (pair address address) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + CAR; # nat : pair nat (pair address address) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + SWAP; # pair nat (pair address address) : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + CDDR; # address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) : address + DIG 4; # address : address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) + PAIR; # pair address address : nat : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) + SWAP; # nat : pair address address : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) + PAIR; # pair nat (pair address address) : pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) + PAIR; # pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option mutez) (pair address nat)) (pair nat (pair address address)) + PAIR; # pair (pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option mutez) (pair address nat)) (pair nat (pair address address))) + NIL operation; # list operation : pair (pair (pair nat (pair address address)) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option mutez) (pair address nat)) (pair nat (pair address address))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateParams : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%updateParams : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAADDR; # address : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # lambda (pair nat (pair nat nat)) nat : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # lambda (pair int (pair nat (pair nat nat))) nat : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + DROP; # @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + } + { + PUSH int 4; # int : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : @parameter%updateParams : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : @parameter%updateParams : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @parameter%updateParams + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : @parameter%updateParams + SWAP; # @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # @parameter%updateParams : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : @parameter%updateParams : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # @parameter%updateParams : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair nat (option mutez)) : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair nat (option mutez)) : pair nat (pair nat (option mutez)) : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair nat (option mutez)) : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair nat (option mutez)) : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (option mutez) : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (option mutez) : pair nat (option mutez) : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (option mutez) : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (option mutez) : nat : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # option mutez : nat : nat : nat : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 4; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : option mutez : nat : nat : nat + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : option mutez : nat : nat : nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : option mutez : nat : nat : nat + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + DUP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + CAR; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + SWAP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + CDDR; # pair (address %stabilityFundContractAddress) (address %tokenContractAddress) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat : nat + DIG 6; # nat : pair (address %stabilityFundContractAddress) (address %tokenContractAddress) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat + PAIR; # pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat + SWAP; # pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat + PAIR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez : nat : nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + CDR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + DUP; # pair nat (pair timestamp nat) : pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + CAR; # nat : pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + SWAP; # pair nat (pair timestamp nat) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + CDAR; # timestamp : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat : nat + DIG 6; # nat : timestamp : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + SWAP; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + CDR; # pair (address %developerFundContractAddress) (address %governorContractAddress) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez : nat + DIG 4; # nat : pair (address %developerFundContractAddress) (address %governorContractAddress) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez + PAIR; # pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez + PAIR; # pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : option mutez + SWAP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez + DUP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez + CDR; # pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez + SWAP; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez + CADR; # pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit) : pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : option mutez + DIG 3; # option mutez : pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit) : pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) + PAIR; # pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit)) : pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) + PAIR; # pair (pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) + SWAP; # pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) + PAIR; # pair (pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + NIL operation; # list operation : pair (pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + } + { + SWAP; # @storage : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 2; # @storage : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SENDER; # address : address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EQ; # bool : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + {} + { + PUSH int 2; # int : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%withdraw : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @parameter%withdraw : @parameter%withdraw : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : @parameter%withdraw : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # @parameter%withdraw : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int mutez)) : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair bool (pair int (pair int mutez)) : pair bool (pair int (pair int mutez)) : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # bool : pair bool (pair int (pair int mutez)) : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair bool (pair int (pair int mutez)) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int mutez) : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int (pair int mutez) : pair int (pair int mutez) : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair int (pair int mutez) : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SWAP; # pair int (pair int mutez) : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 0; # nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUG 20; # lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 19; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 20; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int mutez : pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # int : nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 4; # int : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # nat : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # nat : nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + GT; # bool : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 15; # @storage : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 16; # @storage : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAAAR; # nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 17; # lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 18; # lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUP; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat + DUG 21; # lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 20; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 21; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int mutez : pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # int : int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 5; # int : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 9; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ADD; # nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 16; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 17; # nat : nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 1; # mutez : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair int mutez : mutez : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int mutez : pair int mutez : mutez : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 6; # pair int mutez : mutez : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # mutez : mutez : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat mutez) : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CAR; # nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 11; # nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # nat : nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 12; # nat : nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : pair nat nat : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair @some (pair nat nat) : lambda (pair nat (pair nat nat)) nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : nat : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + COMPARE; # int : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + GE; # bool : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF + { + DIG 2; # pair int (pair int mutez) : pair int mutez : int : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair bool (pair int (pair int mutez)) : pair int mutez : int : bool : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair bool (pair int (pair int mutez))) : pair int mutez : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair int mutez : int : bool : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair int mutez : int : bool : nat : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair int mutez : int : bool : nat : nat : address : address : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # nat : pair int mutez : int : bool : nat : nat : address : address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # @parameter%withdraw : pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + PUSH int 11; # int : pair int mutez : int : pair int (pair int mutez) : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + DIG 2; # pair int (pair int mutez) : pair int mutez : int : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : pair bool (pair int (pair int mutez)) : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 3; # pair bool (pair int (pair int mutez)) : pair int mutez : int : bool : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : pair nat (pair bool (pair int (pair int mutez))) : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 4; # pair nat (pair bool (pair int (pair int mutez))) : pair int mutez : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : pair nat (pair nat (pair bool (pair int (pair int mutez)))) : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # pair nat (pair nat (pair bool (pair int (pair int mutez)))) : pair int mutez : int : bool : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))) : pair int mutez : int : bool : nat : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))) : pair int mutez : int : bool : nat : nat : address : address : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : nat : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # nat : pair int mutez : int : bool : nat : nat : address : address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @parameter%withdraw : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # @parameter%withdraw : pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 8; # lambda (pair nat (pair nat nat)) nat : pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DROP; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + }; # pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NIL operation; # list operation : pair int mutez : int : bool : nat : nat : address : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 6; # address : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT unit; # option (contract unit) : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair int mutez : @some : list operation : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int mutez : pair int mutez : @some : list operation : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # pair int mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + UNIT; # unit : mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + TRANSFER_TOKENS; # operation : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONS; # list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 7; # @storage : list operation : pair int mutez : int : bool : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : list operation : pair int mutez : int : bool : nat : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 8; # @storage : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDADAR; # address : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 2; # pair int mutez : @some : list operation : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # pair int mutez : pair int mutez : @some : list operation : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 3; # pair int mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDR; # mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH mutez 1; # mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 1000000000000; # nat : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # nat : nat : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + MUL; # mutez : mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # mutez : @some : list operation : pair int mutez : int : bool : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 5; # bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 9; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair int (pair nat (pair nat nat))) nat + DUG 10; # lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DUG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + EXEC; # nat : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + INT; # int : bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + PAIR; # pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat + DIG 10; # lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 10; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage + DUP; # lambda (pair nat (pair nat nat)) nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage + DUG 11; # lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 11; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : lambda (pair nat (pair nat nat)) nat + DUG 12; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 7; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # int : int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 8; # int : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 8; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # nat : nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : address : @storage : lambda (pair nat (pair nat nat)) nat + DUG 9; # nat : pair @some nat : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : pair int mutez : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 6; # pair int mutez : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # int : pair nat (pair @some nat) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair nat (pair @some nat)) : lambda (pair int (pair nat (pair nat nat))) nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + EXEC; # nat : pair int bool : mutez : @some : list operation : int : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # int : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ISNAT; # option nat : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + IF_SOME + {} + { + UNIT; # unit : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + FAILWITH; # FAILED + }; # @some : nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + ADD; # nat : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + INT; # int : pair int bool : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair int (pair int bool) : mutez : @some : list operation : nat : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # nat : pair int (pair int bool) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair nat (pair int (pair int bool)) : mutez : @some : list operation : address : @storage : lambda (pair nat (pair nat nat)) nat + DIG 4; # address : pair nat (pair int (pair int bool)) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + PAIR; # pair address (pair nat (pair int (pair int bool))) : mutez : @some : list operation : @storage : lambda (pair nat (pair nat nat)) nat + TRANSFER_TOKENS; # operation : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CONS; # list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : lambda (pair nat (pair nat nat)) nat + DUG 2; # @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # @storage : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : @storage : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # @storage : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair (nat %interestIndex) (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + CDDR; # pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage : lambda (pair nat (pair nat nat)) nat + DIG 5; # lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PUSH nat 60; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CADDAR; # timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + NOW; # timestamp : timestamp : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + SUB; # int : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + ISNAT; # option nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + EDIV; # option (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + IF_SOME + { + CAR; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + } + { + UNIT; # unit : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + FAILWITH; # FAILED + }; # nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # @storage : @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 7; # @storage : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + CDDAR; # nat : nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + PAIR; # pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : @storage + DIG 6; # @storage : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADAR; # nat : pair nat nat : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair nat nat) : lambda (pair nat (pair nat nat)) nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EXEC; # nat : pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + DUG 2; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent))) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDR; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CAR; # nat : pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)) : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CDDR; # nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 5; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUP; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + DUG 6; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + CADDAR; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PUSH nat 60; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DUP; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + DIG 8; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair (timestamp %lastInterestIndexUpdateTime) (nat %liquidationFeePercent)))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + CADDAR; # timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + NOW; # timestamp : timestamp : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SUB; # int : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ISNAT; # option nat : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + {} + { + UNIT; # unit : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # @some : nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + EDIV; # option (pair nat nat) : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + IF_SOME + { + CAR; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + } + { + UNIT; # unit : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + FAILWITH; # FAILED + }; # nat : nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + MUL; # nat : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + INT; # int : timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + ADD; # timestamp : nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair timestamp nat : nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # nat : pair timestamp nat : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair nat (pair timestamp nat) : pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + SWAP; # pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress)) : pair nat (pair timestamp nat) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat)) : pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))) : list operation + PAIR; # pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) : list operation + SWAP; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair nat (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair nat (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + NIL operation; # list operation : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + SWAP; # list operation : list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + ITER + { + CONS; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + }; # list operation : pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress)))) + PAIR; # pair (list operation) (pair (pair (pair (nat %collateralizationPercentage) (pair (address %developerFundContractAddress) (address %governorContractAddress))) (pair nat (pair timestamp nat))) (pair (pair (option %ovenMax mutez) (pair (address %ovenProxyContractAddress) (nat %stabilityDevFundSplit))) (pair (nat %stabilityFee) (pair (address %stabilityFundContractAddress) (address %tokenContractAddress))))) + }; \ No newline at end of file diff --git a/smart_contracts/oracle.py b/smart_contracts/oracle.py new file mode 100644 index 00000000..3dc2965a --- /dev/null +++ b/smart_contracts/oracle.py @@ -0,0 +1,421 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +Errors = sp.import_script_from_url("file:common/errors.py") + +################################################################ +# State Machine +################################################################ + +IDLE = 0 +WAITING_FOR_HARBINGER = 1 + +################################################################ +# Contract +################################################################ + +# Contains an Oracle for an XTZ-USD price backed by Harbinger. +# See: https://github.com/tacoinfra/harbinger +class OracleContract(sp.Contract): + # Initialize a new OracleContract contract. + # + # Parameters: + # harbingerContractAddress The address of the Harbinger contract. Defaults to the Coinbase Normalizer. + def __init__( + self, + state = IDLE, + harbingerContractAddress = Addresses.HARBINGER_ADDRESS, + maxDataDelaySec = sp.nat(60 * 30), + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + harbingerContractAddress = harbingerContractAddress, + state = state, + clientCallback = sp.none, + maxDataDelaySec = maxDataDelaySec, + governorContractAddress = governorContractAddress + ) + + ################################################################ + # Public Interface + ################################################################ + + # Disallow direct transfers. + @sp.entry_point + def default(self, param): + sp.set_type(param, sp.TUnit) + sp.failwith(Errors.CANNOT_RECEIVE_FUNDS) + + # Retrieve the price of the XTZ-USD pair. + # + # Parameters: + # callback: A callback to call with the result. Parameter to callback is a single nat. + @sp.entry_point + def getXtzUsdRate(self, callback): + sp.set_type(callback, sp.TContract(sp.TNat)) + + # Can only be called from idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Set state to WAITING_FOR_HARBINGER + self.data.state = WAITING_FOR_HARBINGER + self.data.clientCallback = sp.some(sp.to_address(callback)) + + # Callback to this contract. + harbingerCallback = sp.self_entry_point(entry_point = 'getXtzUsdRate_callback') + sp.set_type(harbingerCallback, sp.TContract(Constants.HARBINGER_DATA_TYPE)) + harbingerParam = (Constants.ASSET_CODE, harbingerCallback) + + harbingerHandle = sp.contract( + sp.TPair(sp.TString, sp.TContract(Constants.HARBINGER_DATA_TYPE)), + self.data.harbingerContractAddress, + entry_point = "get" + ).open_some() + + sp.transfer(harbingerParam, sp.mutez(0), harbingerHandle) + + ################################################################ + # Harbinger Callbacks + ################################################################ + + @sp.entry_point + def getXtzUsdRate_callback(self, result): + sp.set_type(result, Constants.HARBINGER_DATA_TYPE) + + # Can only be called from the WAITING_FOR_HARBINGER state. + sp.verify(self.data.state == WAITING_FOR_HARBINGER, message = Errors.BAD_STATE) + + # Assert data came from Harbinger and is the correct asset. + sp.verify(sp.sender == self.data.harbingerContractAddress, message = Errors.NOT_ORACLE) + returnedAssetCode = sp.fst(result) + sp.verify(returnedAssetCode == Constants.ASSET_CODE, message = Errors.WRONG_ASSET) + + # Assert data is recent. + dataAge = sp.as_nat(sp.now - sp.fst(sp.snd(result))) + sp.verify(dataAge < self.data.maxDataDelaySec, message = Errors.STALE_DATA) + + # Grab callback. Callback will always be `some` in the WAITING_FOR_HARBINGER state. + clientCallback = self.data.clientCallback.open_some() + clientCallback = sp.contract( + sp.TNat, + clientCallback, + '' + ).open_some() + + clientCallbackParam = sp.snd(sp.snd(result)) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call client callback + sp.transfer(clientCallbackParam, sp.mutez(0), clientCallback) + + # Reset state. + self.data.state = IDLE + self.data.clientCallback = sp.none + + ################################################################ + # Governance + ################################################################ + + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # Update the max data delay. + @sp.entry_point + def setMaxDataDelaySec(self, newMaxDataDelaySec): + sp.set_type(newMaxDataDelaySec, sp.TNat) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.maxDataDelaySec = newMaxDataDelaySec + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + DummyContract = sp.import_script_from_url("file:test-helpers/dummy-contract.py") + FakeHarbinger = sp.import_script_from_url("file:test-helpers/fake-harbinger.py") + + ################################################################ + # getXtzUsdRate + ################################################################ + + @sp.add_test(name="getXtzUsdRate - fails when called from bad state") + def test(): + # GIVEN an Oracle contract in the WAITING_FOR_HARBINGER state + scenario = sp.test_scenario() + + oracle = OracleContract( + state = WAITING_FOR_HARBINGER + ) + scenario += oracle + + # AND a DummyContract to receive the retrieved value. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN a price is requested THEN the invocation fails. + callback = sp.contract(sp.TNat, dummyContract.address, entry_point = "natCallback").open_some() + scenario += oracle.getXtzUsdRate(callback).run( + valid = False + ) + + @sp.add_test(name="getXtzUsdRate - fails when called with an amount") + def test(): + # GIVEN an Oracle contract. + scenario = sp.test_scenario() + + oracle = OracleContract( + ) + scenario += oracle + + # AND a DummyContract to receive the retrieved value. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN a price is requested with an amount THEN the invocation fails. + callback = sp.contract(sp.TNat, dummyContract.address, entry_point = "natCallback").open_some() + scenario += oracle.getXtzUsdRate(callback).run( + amount = sp.mutez(1), + valid = False + ) + + @sp.add_test(name="getXtzUsdRate - retrieves correct value") + def test(): + scenario = sp.test_scenario() + + # GIVEN a fake Harbinger contract. + xtzUsdValue = 2310000 # $2.31 + harbinger = FakeHarbinger.FakeHarbingerContract( + harbingerValue = xtzUsdValue, + harbingerUpdateTime = sp.timestamp_from_utc_now(), + harbingerAsset = Constants.ASSET_CODE + ) + scenario += harbinger + + # AND an Oracle contract. + oracle = OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND a DummyContract to receive the retrieved value. + dummyContract = DummyContract.DummyContract() + scenario += dummyContract + + # WHEN a price is requested with an amount + callback = sp.contract(sp.TNat, dummyContract.address, entry_point = "natCallback").open_some() + scenario += oracle.getXtzUsdRate(callback).run( + now = sp.timestamp_from_utc_now() + ) + + # THEN the dummy contract received the data, correctly converted to 10^-18 precision + expectedValue = xtzUsdValue * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(dummyContract.data.natValue == expectedValue) + + # AND the contract state is reset + scenario.verify(oracle.data.state == IDLE) + scenario.verify(oracle.data.clientCallback.is_some() == False) + + ################################################################ + # getXtzUsdRate_callback + ################################################################ + + @sp.add_test(name="getXtzUsdRate_callback - fails when called from bad state") + def test(): + # GIVEN an Oracle contract in the IDLE state + scenario = sp.test_scenario() + + harbingerAddress = Addresses.HARBINGER_ADDRESS + oracle = OracleContract( + harbingerContractAddress = harbingerAddress, + state = IDLE + ) + scenario += oracle + + # WHEN the callback is called THEN the call fails. + harbingerResult = (Constants.ASSET_CODE, (sp.timestamp_from_utc_now(), 2310000)) + scenario += oracle.getXtzUsdRate_callback(harbingerResult).run( + valid = False + ) + + @sp.add_test(name="getXtzUsdRate_callback - fails when not called from harbinger") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + harbingerAddress = Addresses.HARBINGER_ADDRESS + oracle = OracleContract( + harbingerContractAddress = harbingerAddress, + state = WAITING_FOR_HARBINGER + ) + scenario += oracle + + # WHEN the callback is called from someone other than Harbinger THEN the call fails. + harbingerResult = (Constants.ASSET_CODE, (sp.timestamp_from_utc_now(), 2310000)) + notHarbinger = Addresses.NULL_ADDRESS + scenario += oracle.getXtzUsdRate_callback(harbingerResult).run( + sender = notHarbinger, + valid = False + ) + + @sp.add_test(name="getXtzUsdRate_callback - fails when called with wrong asset") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + harbingerAddress = Addresses.HARBINGER_ADDRESS + oracle = OracleContract( + harbingerContractAddress = harbingerAddress, + state = WAITING_FOR_HARBINGER + ) + scenario += oracle + + # WHEN the callback contains data for an asset which is not XTZ-USD THEN the call fails. + harbingerResult = ("BTC-USD", (sp.timestamp_from_utc_now(), 2310000)) + scenario += oracle.getXtzUsdRate_callback(harbingerResult).run( + sender = harbingerAddress, + valid = False + ) + + @sp.add_test(name="getXtzUsdRate_callback - fails when called with stale asset data") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + harbingerAddress = Addresses.HARBINGER_ADDRESS + maxDataDelaySec = 30 + oracle = OracleContract( + harbingerContractAddress = harbingerAddress, + maxDataDelaySec =maxDataDelaySec, + state = WAITING_FOR_HARBINGER + ) + scenario += oracle + + # WHEN the callback is contains data at too old of a timestamp THEN the call fails + nowSecs = 60 + now = sp.timestamp(nowSecs) + staleDataTime = sp.timestamp(nowSecs - maxDataDelaySec - 1) + + harbingerResult = (Constants.ASSET_CODE, (staleDataTime, 2310000)) + scenario += oracle.getXtzUsdRate_callback(harbingerResult).run( + sender = harbingerAddress, + valid = False, + now = now + ) + + ################################################################ + # default + ################################################################ + + @sp.add_test(name="default - fails with calls to the default entrypoint") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + oracle = OracleContract() + scenario += oracle + + # WHEN the default entry point is called THEN the request fails + scenario += oracle.default(sp.unit).run( + amount = sp.mutez(1), + valid = False + ) + + ################################################################ + # setMaxDataDelaySec + ################################################################ + + @sp.add_test(name="setMaxDataDelaySec - succeeds when called by governor") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + oracle = OracleContract( + governorContractAddress = governorContractAddress, + maxDataDelaySec = 30, + ) + scenario += oracle + + # WHEN the setMaxDataDelaySec is called with a new contract + newMaxDataDelaySec = 60 + scenario += oracle.setMaxDataDelaySec(newMaxDataDelaySec).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(oracle.data.maxDataDelaySec == newMaxDataDelaySec) + + @sp.add_test(name="setMaxDataDelaySec - fails when not called by governor") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + oracle = OracleContract( + governorContractAddress = governorContractAddress + ) + scenario += oracle + + # WHEN the setMaxDataDelaySec is called by someone who isn't the governor THEN the call fails + newMaxDataDelaySec = 60 + scenario += oracle.setMaxDataDelaySec(newMaxDataDelaySec).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + oracle = OracleContract( + governorContractAddress = governorContractAddress + ) + scenario += oracle + + # WHEN the setGovernorContract is called with a new contract + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += oracle.setGovernorContract(rotatedAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(oracle.data.governorContractAddress == rotatedAddress) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN an Oracle contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + oracle = OracleContract( + governorContractAddress = governorContractAddress + ) + scenario += oracle + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += oracle.setGovernorContract(rotatedAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) diff --git a/smart_contracts/oracle.tz b/smart_contracts/oracle.tz new file mode 100644 index 00000000..15b23de9 --- /dev/null +++ b/smart_contracts/oracle.tz @@ -0,0 +1,279 @@ +parameter (or (or (unit %default) (contract %getXtzUsdRate nat)) (or (pair %getXtzUsdRate_callback string (pair timestamp nat)) (or (address %setGovernorContract) (nat %setMaxDataDelaySec)))); +storage (pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + PUSH int 19; # int : @parameter%default : @storage + FAILWITH; # FAILED + } + { + # == getXtzUsdRate == + # sp.verify(self.data.state == 0, message = 12) # @parameter%getXtzUsdRate : @storage + PUSH int 0; # int : @parameter%getXtzUsdRate : @storage + DIG 2; # @storage : int : @parameter%getXtzUsdRate + DUP; # @storage : @storage : int : @parameter%getXtzUsdRate + DUG 3; # @storage : int : @parameter%getXtzUsdRate : @storage + CDDDR; # int : int : @parameter%getXtzUsdRate : @storage + COMPARE; # int : @parameter%getXtzUsdRate : @storage + EQ; # bool : @parameter%getXtzUsdRate : @storage + IF + {} + { + PUSH int 12; # int : @parameter%getXtzUsdRate : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%getXtzUsdRate : @storage + PUSH mutez 0; # mutez : @parameter%getXtzUsdRate : @storage + AMOUNT; # mutez : mutez : @parameter%getXtzUsdRate : @storage + COMPARE; # int : @parameter%getXtzUsdRate : @storage + EQ; # bool : @parameter%getXtzUsdRate : @storage + IF + {} + { + PUSH int 15; # int : @parameter%getXtzUsdRate : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate : @storage + SWAP; # @storage : @parameter%getXtzUsdRate + # self.data.state = 1 # @storage : @parameter%getXtzUsdRate + DUP; # @storage : @storage : @parameter%getXtzUsdRate + CAR; # pair (option %clientCallback address) (address %governorContractAddress) : @storage : @parameter%getXtzUsdRate + SWAP; # @storage : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + CDR; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + DUP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + CAR; # address : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + SWAP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + CDAR; # nat : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + PUSH int 1; # int : nat : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + SWAP; # nat : int : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + PAIR; # pair nat int : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + SWAP; # address : pair nat int : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + PAIR; # pair address (pair nat int) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%getXtzUsdRate + SWAP; # pair (option %clientCallback address) (address %governorContractAddress) : pair address (pair nat int) : @parameter%getXtzUsdRate + PAIR; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : @parameter%getXtzUsdRate + # self.data.clientCallback = sp.some(sp.to_address(params)) # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : @parameter%getXtzUsdRate + DUP; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : @parameter%getXtzUsdRate + CDR; # pair address (pair nat int) : pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : @parameter%getXtzUsdRate + SWAP; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : pair address (pair nat int) : @parameter%getXtzUsdRate + CADR; # address : pair address (pair nat int) : @parameter%getXtzUsdRate + DIG 2; # @parameter%getXtzUsdRate : address : pair address (pair nat int) + ADDRESS; # address : address : pair address (pair nat int) + SOME; # option address : address : pair address (pair nat int) + PAIR; # pair (option address) address : pair address (pair nat int) + PAIR; # pair (pair (option address) address) (pair address (pair nat int)) + # sp.transfer(('XTZ-USD', sp.self_entry_point('getXtzUsdRate_callback')), sp.tez(0), sp.contract(sp.TPair(sp.TString, sp.TContract(sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)))), self.data.harbingerContractAddress, entry_point='get').open_some()) # pair (pair (option address) address) (pair address (pair nat int)) + DUP; # pair (pair (option address) address) (pair address (pair nat int)) : pair (pair (option address) address) (pair address (pair nat int)) + CDAR; # address : pair (pair (option address) address) (pair address (pair nat int)) + CONTRACT %get (pair string (contract (pair string (pair timestamp nat)))); # option (contract (pair string (contract (pair string (pair timestamp nat))))) : pair (pair (option address) address) (pair address (pair nat int)) + IF_SOME + {} + { + UNIT; # unit : pair (pair (option address) address) (pair address (pair nat int)) + FAILWITH; # FAILED + }; # @some : pair (pair (option address) address) (pair address (pair nat int)) + NIL operation; # list operation : @some : pair (pair (option address) address) (pair address (pair nat int)) + SWAP; # @some : list operation : pair (pair (option address) address) (pair address (pair nat int)) + PUSH mutez 0; # mutez : @some : list operation : pair (pair (option address) address) (pair address (pair nat int)) + SELF %getXtzUsdRate_callback; # contract (pair string (pair timestamp nat)) : mutez : @some : list operation : pair (pair (option address) address) (pair address (pair nat int)) + PUSH string "XTZ-USD"; # string : contract (pair string (pair timestamp nat)) : mutez : @some : list operation : pair (pair (option address) address) (pair address (pair nat int)) + PAIR; # pair string (contract (pair string (pair timestamp nat))) : mutez : @some : list operation : pair (pair (option address) address) (pair address (pair nat int)) + TRANSFER_TOKENS; # operation : list operation : pair (pair (option address) address) (pair address (pair nat int)) + CONS; # list operation : pair (pair (option address) address) (pair address (pair nat int)) + }; # list operation : pair (pair (option address) address) (pair address (pair nat int)) + } + { + IF_LEFT + { + # == getXtzUsdRate_callback == + # sp.verify(self.data.state == 1, message = 12) # @parameter%getXtzUsdRate_callback : @storage + PUSH int 1; # int : @parameter%getXtzUsdRate_callback : @storage + DIG 2; # @storage : int : @parameter%getXtzUsdRate_callback + DUP; # @storage : @storage : int : @parameter%getXtzUsdRate_callback + DUG 3; # @storage : int : @parameter%getXtzUsdRate_callback : @storage + CDDDR; # int : int : @parameter%getXtzUsdRate_callback : @storage + COMPARE; # int : @parameter%getXtzUsdRate_callback : @storage + EQ; # bool : @parameter%getXtzUsdRate_callback : @storage + IF + {} + { + PUSH int 12; # int : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate_callback : @storage + SWAP; # @storage : @parameter%getXtzUsdRate_callback + # sp.verify(sp.sender == self.data.harbingerContractAddress, message = 3) # @storage : @parameter%getXtzUsdRate_callback + DUP; # @storage : @storage : @parameter%getXtzUsdRate_callback + DUG 2; # @storage : @parameter%getXtzUsdRate_callback : @storage + CDAR; # address : @parameter%getXtzUsdRate_callback : @storage + SENDER; # address : address : @parameter%getXtzUsdRate_callback : @storage + COMPARE; # int : @parameter%getXtzUsdRate_callback : @storage + EQ; # bool : @parameter%getXtzUsdRate_callback : @storage + IF + {} + { + PUSH int 3; # int : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate_callback : @storage + # sp.verify(sp.fst(params) == 'XTZ-USD', message = 14) # @parameter%getXtzUsdRate_callback : @storage + DUP; # @parameter%getXtzUsdRate_callback : @parameter%getXtzUsdRate_callback : @storage + CAR; # string : @parameter%getXtzUsdRate_callback : @storage + PUSH string "XTZ-USD"; # string : string : @parameter%getXtzUsdRate_callback : @storage + COMPARE; # int : @parameter%getXtzUsdRate_callback : @storage + EQ; # bool : @parameter%getXtzUsdRate_callback : @storage + IF + {} + { + PUSH int 14; # int : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate_callback : @storage + SWAP; # @storage : @parameter%getXtzUsdRate_callback + # sp.verify(sp.as_nat(sp.now - sp.fst(sp.snd(params))) < self.data.maxDataDelaySec, message = 17) # @storage : @parameter%getXtzUsdRate_callback + DUP; # @storage : @storage : @parameter%getXtzUsdRate_callback + DUG 2; # @storage : @parameter%getXtzUsdRate_callback : @storage + CDDAR; # nat : @parameter%getXtzUsdRate_callback : @storage + SWAP; # @parameter%getXtzUsdRate_callback : nat : @storage + DUP; # @parameter%getXtzUsdRate_callback : @parameter%getXtzUsdRate_callback : nat : @storage + DUG 2; # @parameter%getXtzUsdRate_callback : nat : @parameter%getXtzUsdRate_callback : @storage + CDAR; # timestamp : nat : @parameter%getXtzUsdRate_callback : @storage + NOW; # timestamp : timestamp : nat : @parameter%getXtzUsdRate_callback : @storage + SUB; # int : nat : @parameter%getXtzUsdRate_callback : @storage + ISNAT; # option nat : nat : @parameter%getXtzUsdRate_callback : @storage + IF_SOME + {} + { + UNIT; # unit : nat : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%getXtzUsdRate_callback : @storage + COMPARE; # int : @parameter%getXtzUsdRate_callback : @storage + LT; # bool : @parameter%getXtzUsdRate_callback : @storage + IF + {} + { + PUSH int 17; # int : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%getXtzUsdRate_callback : @storage + # sp.transfer(sp.snd(sp.snd(params)) * 1000000000000, sp.tez(0), sp.contract(sp.TNat, self.data.clientCallback.open_some()).open_some()) # @parameter%getXtzUsdRate_callback : @storage + NIL operation; # list operation : @parameter%getXtzUsdRate_callback : @storage + DIG 2; # @storage : list operation : @parameter%getXtzUsdRate_callback + DUP; # @storage : @storage : list operation : @parameter%getXtzUsdRate_callback + DUG 3; # @storage : list operation : @parameter%getXtzUsdRate_callback : @storage + CAAR; # option address : list operation : @parameter%getXtzUsdRate_callback : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%getXtzUsdRate_callback : @storage + CONTRACT nat; # option (contract nat) : list operation : @parameter%getXtzUsdRate_callback : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%getXtzUsdRate_callback : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%getXtzUsdRate_callback : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%getXtzUsdRate_callback : @storage + PUSH nat 1000000000000; # nat : mutez : @some : list operation : @parameter%getXtzUsdRate_callback : @storage + DIG 4; # @parameter%getXtzUsdRate_callback : nat : mutez : @some : list operation : @storage + CDDR; # nat : nat : mutez : @some : list operation : @storage + MUL; # nat : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + SWAP; # @storage : list operation + # self.data.state = 0 # @storage : list operation + DUP; # @storage : @storage : list operation + CAR; # pair (option %clientCallback address) (address %governorContractAddress) : @storage : list operation + SWAP; # @storage : pair (option %clientCallback address) (address %governorContractAddress) : list operation + CDR; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : list operation + DUP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : list operation + CAR; # address : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : list operation + SWAP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : address : pair (option %clientCallback address) (address %governorContractAddress) : list operation + CDAR; # nat : address : pair (option %clientCallback address) (address %governorContractAddress) : list operation + PUSH int 0; # int : nat : address : pair (option %clientCallback address) (address %governorContractAddress) : list operation + SWAP; # nat : int : address : pair (option %clientCallback address) (address %governorContractAddress) : list operation + PAIR; # pair nat int : address : pair (option %clientCallback address) (address %governorContractAddress) : list operation + SWAP; # address : pair nat int : pair (option %clientCallback address) (address %governorContractAddress) : list operation + PAIR; # pair address (pair nat int) : pair (option %clientCallback address) (address %governorContractAddress) : list operation + SWAP; # pair (option %clientCallback address) (address %governorContractAddress) : pair address (pair nat int) : list operation + PAIR; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : list operation + # self.data.clientCallback = sp.none # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : list operation + DUP; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : list operation + CDR; # pair address (pair nat int) : pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : list operation + SWAP; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair nat int)) : pair address (pair nat int) : list operation + CADR; # address : pair address (pair nat int) : list operation + NONE address; # option address : address : pair address (pair nat int) : list operation + PAIR; # pair (option address) address : pair address (pair nat int) : list operation + PAIR; # pair (pair (option address) address) (pair address (pair nat int)) : list operation + SWAP; # list operation : pair (pair (option address) address) (pair address (pair nat int)) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CADR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CDR; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : @storage : @parameter%setGovernorContract + SWAP; # @storage : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : @parameter%setGovernorContract + CAAR; # option address : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : @parameter%setGovernorContract + DIG 2; # @parameter%setGovernorContract : option address : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) + SWAP; # option address : @parameter%setGovernorContract : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) + PAIR; # pair (option address) @parameter%setGovernorContract : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) + PAIR; # pair (pair (option address) @parameter%setGovernorContract) (pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state))) + } + { + SWAP; # @storage : @parameter%setMaxDataDelaySec + # == setMaxDataDelaySec == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setMaxDataDelaySec + DUP; # @storage : @storage : @parameter%setMaxDataDelaySec + DUG 2; # @storage : @parameter%setMaxDataDelaySec : @storage + CADR; # address : @parameter%setMaxDataDelaySec : @storage + SENDER; # address : address : @parameter%setMaxDataDelaySec : @storage + COMPARE; # int : @parameter%setMaxDataDelaySec : @storage + EQ; # bool : @parameter%setMaxDataDelaySec : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setMaxDataDelaySec : @storage + FAILWITH; # FAILED + }; # @parameter%setMaxDataDelaySec : @storage + SWAP; # @storage : @parameter%setMaxDataDelaySec + # self.data.maxDataDelaySec = params # @storage : @parameter%setMaxDataDelaySec + DUP; # @storage : @storage : @parameter%setMaxDataDelaySec + CAR; # pair (option %clientCallback address) (address %governorContractAddress) : @storage : @parameter%setMaxDataDelaySec + SWAP; # @storage : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + CDR; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + DUP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + CAR; # address : pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + SWAP; # pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state)) : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + CDDR; # int : address : pair (option %clientCallback address) (address %governorContractAddress) : @parameter%setMaxDataDelaySec + DIG 3; # @parameter%setMaxDataDelaySec : int : address : pair (option %clientCallback address) (address %governorContractAddress) + PAIR; # pair @parameter%setMaxDataDelaySec int : address : pair (option %clientCallback address) (address %governorContractAddress) + SWAP; # address : pair @parameter%setMaxDataDelaySec int : pair (option %clientCallback address) (address %governorContractAddress) + PAIR; # pair address (pair @parameter%setMaxDataDelaySec int) : pair (option %clientCallback address) (address %governorContractAddress) + SWAP; # pair (option %clientCallback address) (address %governorContractAddress) : pair address (pair @parameter%setMaxDataDelaySec int) + PAIR; # pair (pair (option %clientCallback address) (address %governorContractAddress)) (pair address (pair @parameter%setMaxDataDelaySec int)) + }; # pair (pair (option address) @parameter%setGovernorContract) (pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state))) + NIL operation; # list operation : pair (pair (option address) @parameter%setGovernorContract) (pair (address %harbingerContractAddress) (pair (nat %maxDataDelaySec) (int %state))) + }; # list operation : pair (pair (option address) address) (pair address (pair nat int)) + }; # list operation : pair (pair (option address) address) (pair address (pair nat int)) + PAIR; # pair (list operation) (pair (pair (option address) address) (pair address (pair nat int))) + }; \ No newline at end of file diff --git a/smart_contracts/oven-factory.py b/smart_contracts/oven-factory.py new file mode 100644 index 00000000..1961f8bf --- /dev/null +++ b/smart_contracts/oven-factory.py @@ -0,0 +1,644 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Errors = sp.import_script_from_url("file:common/errors.py") +Oven = sp.import_script_from_url("file:oven.py") + +################################################################ +# State Machine States. +################################################################ + +IDLE = 0 +WAITING_FOR_INTEREST_INDEX = 1 + +################################################################ +# Contract +################################################################ + +class OvenFactoryContract(sp.Contract): + def __init__( + self, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ovenRegistryContractAddress = Addresses.OVEN_REGISTRY_ADDRESS, + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS, + minterContractAddress = Addresses.MINTER_ADDRESS, + state = IDLE, + makeOvenOwner = sp.none, + initialDelegate = sp.some(sp.key_hash("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf")) + ): + self.ovenContract = Oven.OvenContract() + + self.exception_optimization_level = "DefaultUnit" + + self.init( + governorContractAddress = governorContractAddress, + ovenProxyContractAddress = ovenProxyContractAddress, + ovenRegistryContractAddress = ovenRegistryContractAddress, + initialDelegate = initialDelegate, + state = state, + minterContractAddress = minterContractAddress, + + # registers + makeOvenOwner = makeOvenOwner + ) + + ################################################################ + # Public Interface + ################################################################ + + @sp.entry_point + def makeOven(self, param): + sp.set_type(param, sp.TUnit) + + # Ensure contract is IDLE. + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Update state and save sender + self.data.state = WAITING_FOR_INTEREST_INDEX + self.data.makeOvenOwner = sp.some(sp.sender) + + # Call Minter contract. + callback = sp.self_entry_point(entry_point = "makeOven_minterCallback") + minterContractHandle = sp.contract( + sp.TContract(sp.TNat), + self.data.minterContractAddress, + 'getInterestIndex' + ).open_some() + sp.transfer(callback, sp.mutez(0), minterContractHandle) + + # Disallow direct transfers. + @sp.entry_point + def default(self, param): + sp.set_type(param, sp.TUnit) + sp.failwith(Errors.CANNOT_RECEIVE_FUNDS) + + ################################################################ + # Minter Interface + ################################################################ + + @sp.entry_point + def makeOven_minterCallback(self, param): + sp.set_type(param, sp.TNat) + + # Verify sender was Minter. + sp.verify(sp.sender == self.data.minterContractAddress, message = Errors.NOT_MINTER) + + # Verify in correct state. + sp.verify(self.data.state == WAITING_FOR_INTEREST_INDEX, message = Errors.BAD_STATE) + ovenOwner = self.data.makeOvenOwner.open_some() + + # Originate a new oven contract + storage = sp.record( + borrowedTokens = sp.nat(0), + interestIndex = sp.to_int(param), + isLiquidated = False, + ovenProxyContractAddress = self.data.ovenProxyContractAddress, + owner = ovenOwner, + stabilityFeeTokens = sp.int(0), + ) + newContract = sp.create_contract(storage = storage, contract = self.ovenContract, baker = self.data.initialDelegate) + + # Add the contract to the oven registry. + registryParam = (newContract, ovenOwner) + ovenRegistryHandle = sp.contract( + sp.TPair(sp.TAddress, sp.TAddress), + self.data.ovenRegistryContractAddress, + 'addOven' + ).open_some() + sp.transfer(registryParam, sp.mutez(0), ovenRegistryHandle) + + # Reset state + self.data.state = IDLE + self.data.makeOvenOwner = sp.none + + ################################################################ + # Governance Functions + ################################################################ + + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # Update the oven registry contract address. + @sp.entry_point + def setOvenRegistryContract(self, newOvenRegistryContractAddress): + sp.set_type(newOvenRegistryContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.ovenRegistryContractAddress = newOvenRegistryContractAddress + + # Update the oven proxy contract address. + @sp.entry_point + def setOvenProxyContract(self, newOvenProxyContractAddress): + sp.set_type(newOvenProxyContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.ovenProxyContractAddress = newOvenProxyContractAddress + + # Update the minter contract address. + @sp.entry_point + def setMinterContract(self, newMinterContract): + sp.set_type(newMinterContract, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.minterContractAddress = newMinterContract + + # Update the initial delegate address. + @sp.entry_point + def setInitialDelegate(self, newInitialDelegate): + sp.set_type(newInitialDelegate, sp.TOption(sp.TKeyHash)) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.initialDelegate = newInitialDelegate + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + Minter = sp.import_script_from_url("file:minter.py") + OvenRegistry = sp.import_script_from_url("file:oven-registry.py") + + ################################################################ + # makeOven + ################################################################ + + @sp.add_test(name="makeOven succeeds") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND a Minter contract. + minter = Minter.MinterContract( + governorContractAddress = governorContractAddress + ) + scenario += minter + + # AND an OvenFactory contract + ovenFactory = OvenFactoryContract( + minterContractAddress = minter.address, + ovenRegistryContractAddress = ovenRegistry.address, + state = IDLE, + makeOvenOwner = sp.none + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven is called THEN the request succeeds. + ovenOwner = Addresses.OVEN_OWNER_ADDRESS + scenario += ovenFactory.makeOven(sp.unit).run( + now = sp.timestamp_from_utc_now(), + sender = ovenOwner + ) + + @sp.add_test(name="makeOven - fails in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND a Minter contract. + minter = Minter.MinterContract( + governorContractAddress = governorContractAddress + ) + scenario += minter + + # AND an OvenFactory contract in the WAITING_FOR_INTEREST_INDEX state + ovenFactory = OvenFactoryContract( + minterContractAddress = minter.address, + ovenRegistryContractAddress = ovenRegistry.address, + state = WAITING_FOR_INTEREST_INDEX, + makeOvenOwner = sp.none + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven is called THEN the request fails. + ovenOwner = Addresses.OVEN_OWNER_ADDRESS + scenario += ovenFactory.makeOven(sp.unit).run( + sender = ovenOwner, + now = sp.timestamp_from_utc_now(), + valid = False + ) + + @sp.add_test(name="makeOven - fails with amount attached") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND a Minter contract. + minter = Minter.MinterContract( + governorContractAddress = governorContractAddress + ) + scenario += minter + + # AND an OvenFactory contract + ovenFactory = OvenFactoryContract( + minterContractAddress = minter.address, + ovenRegistryContractAddress = ovenRegistry.address, + state = IDLE, + makeOvenOwner = sp.none + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven is called with an amount THEN the request fails. + ovenOwner = Addresses.OVEN_OWNER_ADDRESS + scenario += ovenFactory.makeOven(sp.unit).run( + sender = ovenOwner, + amount = sp.mutez(1), + now = sp.timestamp_from_utc_now(), + valid = False + ) + + ############################################################### + # makeOven_minterCallback + ############################################################### + + @sp.add_test(name="makeOven_minterCallback - fails when not called from minter") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND an OvenFactory contract + ovenOwner = sp.some(Addresses.OVEN_OWNER_ADDRESS) + minterContractAddress = Addresses.MINTER_ADDRESS + ovenFactory = OvenFactoryContract( + minterContractAddress = minterContractAddress, + ovenRegistryContractAddress = ovenRegistry.address, + state = WAITING_FOR_INTEREST_INDEX, + makeOvenOwner = ovenOwner + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven_minterCallback entry point is called by someone other than the minter THEN the request fails + interestIndex = 1 + notMinter = Addresses.NULL_ADDRESS + scenario += ovenFactory.makeOven_minterCallback(interestIndex).run( + sender = notMinter, + valid = False + ) + + @sp.add_test(name="makeOven_minterCallback - fails when called in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND an OvenFactory contract in the IDLE state + minterContractAddress = Addresses.MINTER_ADDRESS + ovenOwner = sp.some(Addresses.OVEN_OWNER_ADDRESS) + ovenFactory = OvenFactoryContract( + minterContractAddress = minterContractAddress, + state = IDLE, + makeOvenOwner = ovenOwner + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven_minterCallback entry point is called THEN the request fails + interestIndex = 1 + scenario += ovenFactory.makeOven_minterCallback(interestIndex).run( + sender = minterContractAddress, + valid = False + ) + + @sp.add_test(name="makeOven_minterCallback - succeeds and resets state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # AND an OvenFactory contract in the IDLE state + minterContractAddress = Addresses.MINTER_ADDRESS + ovenOwner = sp.some(Addresses.OVEN_OWNER_ADDRESS) + ovenFactory = OvenFactoryContract( + minterContractAddress = minterContractAddress, + state = WAITING_FOR_INTEREST_INDEX, + makeOvenOwner = ovenOwner + ) + scenario += ovenFactory + + # AND OvenRegistry is bound to OvenFactory + scenario += ovenRegistry.setOvenFactoryContract( + ovenFactory.address + ).run( + sender = governorContractAddress + ) + + # WHEN the makeOven_minterCallback entry point is called + interestIndex = sp.nat(1) + scenario += ovenFactory.makeOven_minterCallback(interestIndex).run( + sender = minterContractAddress, + ) + + # THEN the call succeeds and the state is reset. + scenario.verify(ovenFactory.data.state == IDLE) + scenario.verify(ovenFactory.data.makeOvenOwner.is_some() == False) + + ################################################################ + # default + ################################################################ + + @sp.add_test(name="default - fails with calls to the default entrypoint") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the default entry point is called THEN the request fails + scenario += ovenFactory.default(sp.unit).run( + amount = sp.mutez(1), + valid = False + ) + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setGovernorContract is called with a new contract + newGovernorContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setGovernorContract(newGovernorContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenFactory.data.governorContractAddress == newGovernorContractAddress) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + newGovernorContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setGovernorContract(newGovernorContractAddress).run( + sender = newGovernorContractAddress, + valid = False + ) + + ################################################################ + # setOvenRegistryContract + ################################################################ + + @sp.add_test(name="setOvenRegistryContract - succeeds when called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setOvenRegistryContract is called with a new contract + newOvenRegistryContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setOvenRegistryContract(newOvenRegistryContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenFactory.data.ovenRegistryContractAddress == newOvenRegistryContractAddress) + + @sp.add_test(name="setOvenRegistryContract - fails when not called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setOvenRegistryContract is called by someone who isn't the governor THEN the call fails + newOvenRegistryContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setOvenRegistryContract(newOvenRegistryContractAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setOvenProxyContract + ################################################################ + + @sp.add_test(name="setOvenProxyContract - succeeds when called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setOvenProxyContract is called with a new contract + newOvenProxyContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setOvenProxyContract(newOvenProxyContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenFactory.data.ovenProxyContractAddress == newOvenProxyContractAddress) + + @sp.add_test(name="setOvenProxyContract - fails when not called by governor") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenFactory contract + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setOvenProxyContract is called by someone who isn't the governor THEN the call fails + newOvenProxyContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setOvenProxyContract(newOvenProxyContractAddress).run( + sender = newOvenProxyContractAddress, + valid = False + ) + + ################################################################ + # setMinterContract + ################################################################ + + @sp.add_test(name="setMinterContract - succeeds when called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setMinterContract is called with a new contract + newMinterContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setMinterContract(newMinterContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenFactory.data.minterContractAddress == newMinterContractAddress) + + @sp.add_test(name="setMinterContract - fails when not called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setMinterContract is called by someone who isn't the governor THEN the call fails + newMinterContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenFactory.setMinterContract(newMinterContractAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setInitialDelegate + ################################################################ + + @sp.add_test(name="setInitialDelegate - succeeds when called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress, + initialDelegate = sp.none + ) + scenario += ovenFactory + + # WHEN the setInitialDelegate is called with a new contract + newInitialDelegate = sp.some(sp.key_hash("tz1NRTQeqcuwybgrZfJavBY3of83u8uLpFBj")) + scenario += ovenFactory.setInitialDelegate(newInitialDelegate).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenFactory.data.initialDelegate.open_some() == newInitialDelegate.open_some()) + + @sp.add_test(name="setInitialDelegate - fails when not called by governor") + def test(): + # GIVEN an OvenFactory contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenFactory = OvenFactoryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenFactory + + # WHEN the setInitialDelegate is called by someone who isn't the governor THEN the call fails + newInitialDelegate = sp.some(sp.key_hash("tz1NRTQeqcuwybgrZfJavBY3of83u8uLpFBj")) + scenario += ovenFactory.setInitialDelegate(newInitialDelegate).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) diff --git a/smart_contracts/oven-factory.tz b/smart_contracts/oven-factory.tz new file mode 100644 index 00000000..483f9493 --- /dev/null +++ b/smart_contracts/oven-factory.tz @@ -0,0 +1,946 @@ +parameter (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))); +storage (pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + PUSH int 19; # int : @parameter%default : @storage + FAILWITH; # FAILED + } + { + DROP; # @storage + # == makeOven == + # sp.verify(self.data.state == 0, message = 12) # @storage + DUP; # @storage : @storage + CDDDR; # int : @storage + PUSH int 0; # int : int : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 12; # int : @storage + FAILWITH; # FAILED + }; # @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @storage + PUSH mutez 0; # mutez : @storage + AMOUNT; # mutez : mutez : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 15; # int : @storage + FAILWITH; # FAILED + }; # @storage + # self.data.state = 1 # @storage + DUP; # @storage : @storage + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @storage + SWAP; # @storage : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + DUP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + CAR; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + CDAR; # address : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PUSH int 1; # int : address : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # address : int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair address int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair address int : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + PAIR; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + # self.data.makeOvenOwner = sp.some(sp.sender) # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + DUP; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + SWAP; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + DUP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + CAR; # address : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + CDAR; # option key_hash : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + SENDER; # address : option key_hash : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + SOME; # option address : option key_hash : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + SWAP; # option key_hash : option address : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + PAIR; # pair (option key_hash) (option address) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + SWAP; # address : pair (option key_hash) (option address) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + PAIR; # pair address (pair (option key_hash) (option address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) + PAIR; # pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + # sp.transfer(sp.self_entry_point('makeOven_minterCallback'), sp.tez(0), sp.contract(sp.TContract(sp.TNat), self.data.minterContractAddress, entry_point='getInterestIndex').open_some()) # pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + DUP; # pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + CDAAR; # address : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + CONTRACT %getInterestIndex (contract nat); # option (contract (contract nat)) : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + IF_SOME + {} + { + UNIT; # unit : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + FAILWITH; # FAILED + }; # @some : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + NIL operation; # list operation : @some : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + SWAP; # @some : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + PUSH mutez 0; # mutez : @some : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + SELF %makeOven_minterCallback; # contract nat : mutez : @some : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + TRANSFER_TOKENS; # operation : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + CONS; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + }; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%makeOven_minterCallback + # == makeOven_minterCallback == + # sp.verify(sp.sender == self.data.minterContractAddress, message = 5) # @storage : @parameter%makeOven_minterCallback + DUP; # @storage : @storage : @parameter%makeOven_minterCallback + DUG 2; # @storage : @parameter%makeOven_minterCallback : @storage + CDAAR; # address : @parameter%makeOven_minterCallback : @storage + SENDER; # address : address : @parameter%makeOven_minterCallback : @storage + COMPARE; # int : @parameter%makeOven_minterCallback : @storage + EQ; # bool : @parameter%makeOven_minterCallback : @storage + IF + {} + { + PUSH int 5; # int : @parameter%makeOven_minterCallback : @storage + FAILWITH; # FAILED + }; # @parameter%makeOven_minterCallback : @storage + # sp.verify(self.data.state == 1, message = 12) # @parameter%makeOven_minterCallback : @storage + PUSH int 1; # int : @parameter%makeOven_minterCallback : @storage + DIG 2; # @storage : int : @parameter%makeOven_minterCallback + DUP; # @storage : @storage : int : @parameter%makeOven_minterCallback + DUG 3; # @storage : int : @parameter%makeOven_minterCallback : @storage + CDDDR; # int : int : @parameter%makeOven_minterCallback : @storage + COMPARE; # int : @parameter%makeOven_minterCallback : @storage + EQ; # bool : @parameter%makeOven_minterCallback : @storage + IF + {} + { + PUSH int 12; # int : @parameter%makeOven_minterCallback : @storage + FAILWITH; # FAILED + }; # @parameter%makeOven_minterCallback : @storage + # create_contract_102 = sp.local("create_contract_102", create contract ...) # @parameter%makeOven_minterCallback : @storage + PUSH int 0; # int : @parameter%makeOven_minterCallback : @storage + DIG 2; # @storage : int : @parameter%makeOven_minterCallback + DUP; # @storage : @storage : int : @parameter%makeOven_minterCallback + DUG 3; # @storage : int : @parameter%makeOven_minterCallback : @storage + CADDR; # option address : int : @parameter%makeOven_minterCallback : @storage + IF_SOME + {} + { + UNIT; # unit : int : @parameter%makeOven_minterCallback : @storage + FAILWITH; # FAILED + }; # @some : int : @parameter%makeOven_minterCallback : @storage + PAIR %owner %stabilityFeeTokens; # pair (@some %owner) (int %stabilityFeeTokens) : @parameter%makeOven_minterCallback : @storage + DIG 2; # @storage : pair (@some %owner) (int %stabilityFeeTokens) : @parameter%makeOven_minterCallback + DUP; # @storage : @storage : pair (@some %owner) (int %stabilityFeeTokens) : @parameter%makeOven_minterCallback + DUG 3; # @storage : pair (@some %owner) (int %stabilityFeeTokens) : @parameter%makeOven_minterCallback : @storage + CDADR; # address : pair (@some %owner) (int %stabilityFeeTokens) : @parameter%makeOven_minterCallback : @storage + PAIR %ovenProxyContractAddress; # pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @parameter%makeOven_minterCallback : @storage + PUSH bool False; # bool : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @parameter%makeOven_minterCallback : @storage + DIG 2; # @parameter%makeOven_minterCallback : bool : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @storage + INT; # int : bool : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @storage + PAIR %interestIndex %isLiquidated; # pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @storage + PUSH nat 0; # nat : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @storage + PAIR %borrowedTokens; # pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated)) : pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens)) : @storage + PAIR; # pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) : @storage + PUSH mutez 0; # mutez : pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) : @storage + DIG 2; # @storage : mutez : pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) + DUP; # @storage : @storage : mutez : pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) + DUG 3; # @storage : mutez : pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) : @storage + CADAR; # option key_hash : mutez : pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (@some %owner) (int %stabilityFeeTokens))) : @storage + CREATE_CONTRACT + { parameter (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))); + storage (pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)))); + code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%borrow + # == borrow == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%borrow + DUP; # @storage : @storage : @parameter%borrow + DUG 2; # @storage : @parameter%borrow : @storage + CDDAR; # address : @parameter%borrow : @storage + SENDER; # address : address : @parameter%borrow : @storage + COMPARE; # int : @parameter%borrow : @storage + EQ; # bool : @parameter%borrow : @storage + IF + {} + { + PUSH int 6; # int : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @parameter%borrow : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%borrow : @storage + PUSH mutez 0; # mutez : @parameter%borrow : @storage + AMOUNT; # mutez : mutez : @parameter%borrow : @storage + COMPARE; # int : @parameter%borrow : @storage + EQ; # bool : @parameter%borrow : @storage + IF + {} + { + PUSH int 15; # int : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @parameter%borrow : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))), self.data.ovenProxyContractAddress, entry_point='borrow').open_some()) # @parameter%borrow : @storage + NIL operation; # list operation : @parameter%borrow : @storage + DIG 2; # @storage : list operation : @parameter%borrow + DUP; # @storage : @storage : list operation : @parameter%borrow + DUG 3; # @storage : list operation : @parameter%borrow : @storage + CDAR; # address : list operation : @parameter%borrow : @storage + CONTRACT %borrow (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) : list operation : @parameter%borrow : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%borrow : @storage + BALANCE; # mutez : @some : list operation : @parameter%borrow : @storage + DIG 3; # @parameter%borrow : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%borrow : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%borrow : mutez : @some : list operation + DUG 5; # @storage : @parameter%borrow : mutez : @some : list operation : @storage + CADAR; # int : @parameter%borrow : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%borrow : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%borrow : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%borrow : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%borrow : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%borrow : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + IF_LEFT + { + DROP; # @storage + # == default == + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, self.data.interestIndex)))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TInt)))))), self.data.ovenProxyContractAddress, entry_point='deposit').open_some()) # @storage + DUP; # @storage : @storage + CDAR; # address : @storage + CONTRACT %deposit (pair address (pair address (pair nat (pair nat (pair bool (pair int int)))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int int))))))) : @storage + IF_SOME + {} + { + UNIT; # unit : @storage + FAILWITH; # FAILED + }; # @some : @storage + NIL operation; # list operation : @some : @storage + SWAP; # @some : list operation : @storage + BALANCE; # mutez : @some : list operation : @storage + DIG 3; # @storage : mutez : @some : list operation + DUP; # @storage : @storage : mutez : @some : list operation + CADAR; # int : @storage : mutez : @some : list operation + SWAP; # @storage : int : mutez : @some : list operation + DUP; # @storage : @storage : int : mutez : @some : list operation + DUG 5; # @storage : int : mutez : @some : list operation : @storage + CDDDR; # int : int : mutez : @some : list operation : @storage + PAIR; # pair int int : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int int : mutez : @some : list operation + DUP; # @storage : @storage : pair int int : mutez : @some : list operation + DUG 5; # @storage : pair int int : mutez : @some : list operation : @storage + CADDR; # bool : pair int int : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int int) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int int) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int int) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int int) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int int) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int int))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + DROP; # @storage + # == liquidate == + # sp.verify(sp.amount == sp.tez(0), message = 15) # @storage + PUSH mutez 0; # mutez : @storage + AMOUNT; # mutez : mutez : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 15; # int : @storage + FAILWITH; # FAILED + }; # @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, sp.sender))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TAddress))))))), self.data.ovenProxyContractAddress, entry_point='liquidate').open_some()) # @storage + DUP; # @storage : @storage + CDAR; # address : @storage + CONTRACT %liquidate (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) : @storage + IF_SOME + {} + { + UNIT; # unit : @storage + FAILWITH; # FAILED + }; # @some : @storage + NIL operation; # list operation : @some : @storage + SWAP; # @some : list operation : @storage + BALANCE; # mutez : @some : list operation : @storage + SENDER; # address : mutez : @some : list operation : @storage + DIG 4; # @storage : address : mutez : @some : list operation + DUP; # @storage : @storage : address : mutez : @some : list operation + DUG 5; # @storage : address : mutez : @some : list operation : @storage + CADAR; # int : address : mutez : @some : list operation : @storage + PAIR; # pair int address : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int address : mutez : @some : list operation + DUP; # @storage : @storage : pair int address : mutez : @some : list operation + DUG 5; # @storage : pair int address : mutez : @some : list operation : @storage + CDDDR; # int : pair int address : mutez : @some : list operation : @storage + PAIR; # pair int (pair int address) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int address) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int address) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int address) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int address) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%repay + # == repay == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%repay + DUP; # @storage : @storage : @parameter%repay + DUG 2; # @storage : @parameter%repay : @storage + CDDAR; # address : @parameter%repay : @storage + SENDER; # address : address : @parameter%repay : @storage + COMPARE; # int : @parameter%repay : @storage + EQ; # bool : @parameter%repay : @storage + IF + {} + { + PUSH int 6; # int : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @parameter%repay : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%repay : @storage + PUSH mutez 0; # mutez : @parameter%repay : @storage + AMOUNT; # mutez : mutez : @parameter%repay : @storage + COMPARE; # int : @parameter%repay : @storage + EQ; # bool : @parameter%repay : @storage + IF + {} + { + PUSH int 15; # int : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @parameter%repay : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))), self.data.ovenProxyContractAddress, entry_point='repay').open_some()) # @parameter%repay : @storage + NIL operation; # list operation : @parameter%repay : @storage + DIG 2; # @storage : list operation : @parameter%repay + DUP; # @storage : @storage : list operation : @parameter%repay + DUG 3; # @storage : list operation : @parameter%repay : @storage + CDAR; # address : list operation : @parameter%repay : @storage + CONTRACT %repay (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) : list operation : @parameter%repay : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%repay : @storage + BALANCE; # mutez : @some : list operation : @parameter%repay : @storage + DIG 3; # @parameter%repay : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%repay : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%repay : mutez : @some : list operation + DUG 5; # @storage : @parameter%repay : mutez : @some : list operation : @storage + CADAR; # int : @parameter%repay : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%repay : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%repay : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%repay : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%repay : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%repay : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%setDelegate + # == setDelegate == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%setDelegate + DUP; # @storage : @storage : @parameter%setDelegate + DUG 2; # @storage : @parameter%setDelegate : @storage + CDDAR; # address : @parameter%setDelegate : @storage + SENDER; # address : address : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 6; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%setDelegate : @storage + PUSH mutez 0; # mutez : @parameter%setDelegate : @storage + AMOUNT; # mutez : mutez : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 15; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.set_delegate(params) # @parameter%setDelegate : @storage + SET_DELEGATE; # operation : @storage + NIL operation; # list operation : operation : @storage + SWAP; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateState + # == updateState == + # sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = 2) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + DUG 2; # @storage : @parameter%updateState : @storage + CDAR; # address : @parameter%updateState : @storage + SENDER; # address : address : @parameter%updateState : @storage + COMPARE; # int : @parameter%updateState : @storage + EQ; # bool : @parameter%updateState : @storage + IF + {} + { + PUSH int 2; # int : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @parameter%updateState : @storage + # sp.verify(sp.fst(params) == sp.self_address, message = 13) # @parameter%updateState : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : @parameter%updateState : @storage + ADDRESS; # address : @parameter%updateState : @storage + SWAP; # @parameter%updateState : address : @storage + DUP; # @parameter%updateState : @parameter%updateState : address : @storage + DUG 2; # @parameter%updateState : address : @parameter%updateState : @storage + CAR; # address : address : @parameter%updateState : @storage + COMPARE; # int : @parameter%updateState : @storage + EQ; # bool : @parameter%updateState : @storage + IF + {} + { + PUSH int 13; # int : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @parameter%updateState : @storage + SWAP; # @storage : @parameter%updateState + # self.data.borrowedTokens = sp.fst(sp.snd(params)) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + CDR; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @storage : @parameter%updateState + SWAP; # @storage : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + CADR; # pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + DIG 2; # @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) + DUP; # @parameter%updateState : @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) + DUG 3; # @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + CDAR; # nat : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + PAIR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + PAIR; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + # self.data.stabilityFeeTokens = sp.fst(sp.snd(sp.snd(params))) # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + DUP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + CAR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + SWAP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDR; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + DUP; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CAR; # address : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDAR; # address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + DIG 3; # @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) + DUP; # @parameter%updateState : @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) + DUG 4; # @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDDAR; # int : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # address : int : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + PAIR; # pair address int : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # address : pair address int : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + PAIR; # pair address (pair address int) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + PAIR; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + # self.data.interestIndex = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + DUP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + CDR; # pair address (pair address int) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + SWAP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : pair address (pair address int) : @parameter%updateState + CAR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + DUP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + CAR; # nat : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + SWAP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : nat : pair address (pair address int) : @parameter%updateState + CDDR; # bool : nat : pair address (pair address int) : @parameter%updateState + DIG 3; # @parameter%updateState : bool : nat : pair address (pair address int) + DUP; # @parameter%updateState : @parameter%updateState : bool : nat : pair address (pair address int) + DUG 4; # @parameter%updateState : bool : nat : pair address (pair address int) : @parameter%updateState + CDDDAR; # int : bool : nat : pair address (pair address int) : @parameter%updateState + PAIR; # pair int bool : nat : pair address (pair address int) : @parameter%updateState + SWAP; # nat : pair int bool : pair address (pair address int) : @parameter%updateState + PAIR; # pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + PAIR; # pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + # self.data.isLiquidated = sp.snd(sp.snd(sp.snd(sp.snd(params)))) # pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + DUP; # pair (pair nat (pair int bool)) (pair address (pair address int)) : pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + CDR; # pair address (pair address int) : pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + SWAP; # pair (pair nat (pair int bool)) (pair address (pair address int)) : pair address (pair address int) : @parameter%updateState + CAR; # pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + DUP; # pair nat (pair int bool) : pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + CAR; # nat : pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + SWAP; # pair nat (pair int bool) : nat : pair address (pair address int) : @parameter%updateState + CDAR; # int : nat : pair address (pair address int) : @parameter%updateState + DIG 3; # @parameter%updateState : int : nat : pair address (pair address int) + CDDDDR; # bool : int : nat : pair address (pair address int) + SWAP; # int : bool : nat : pair address (pair address int) + PAIR; # pair int bool : nat : pair address (pair address int) + SWAP; # nat : pair int bool : pair address (pair address int) + PAIR; # pair nat (pair int bool) : pair address (pair address int) + PAIR; # pair (pair nat (pair int bool)) (pair address (pair address int)) + NIL operation; # list operation : pair (pair nat (pair int bool)) (pair address (pair address int)) + } + { + SWAP; # @storage : @parameter%withdraw + # == withdraw == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%withdraw + DUP; # @storage : @storage : @parameter%withdraw + DUG 2; # @storage : @parameter%withdraw : @storage + CDDAR; # address : @parameter%withdraw : @storage + SENDER; # address : address : @parameter%withdraw : @storage + COMPARE; # int : @parameter%withdraw : @storage + EQ; # bool : @parameter%withdraw : @storage + IF + {} + { + PUSH int 6; # int : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%withdraw : @storage + PUSH mutez 0; # mutez : @parameter%withdraw : @storage + AMOUNT; # mutez : mutez : @parameter%withdraw : @storage + COMPARE; # int : @parameter%withdraw : @storage + EQ; # bool : @parameter%withdraw : @storage + IF + {} + { + PUSH int 15; # int : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TMutez))))))), self.data.ovenProxyContractAddress, entry_point='withdraw').open_some()) # @parameter%withdraw : @storage + NIL operation; # list operation : @parameter%withdraw : @storage + DIG 2; # @storage : list operation : @parameter%withdraw + DUP; # @storage : @storage : list operation : @parameter%withdraw + DUG 3; # @storage : list operation : @parameter%withdraw : @storage + CDAR; # address : list operation : @parameter%withdraw : @storage + CONTRACT %withdraw (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : list operation : @parameter%withdraw : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%withdraw : @storage + BALANCE; # mutez : @some : list operation : @parameter%withdraw : @storage + DIG 3; # @parameter%withdraw : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%withdraw : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%withdraw : mutez : @some : list operation + DUG 5; # @storage : @parameter%withdraw : mutez : @some : list operation : @storage + CADAR; # int : @parameter%withdraw : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%withdraw : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%withdraw : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%withdraw : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%withdraw : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%withdraw : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (unit %makeOven)) (or (nat %makeOven_minterCallback) (address %setGovernorContract))) (or (or (option %setInitialDelegate key_hash) (address %setMinterContract)) (or (address %setOvenProxyContract) (address %setOvenRegistryContract)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : pair (pair nat (pair int bool)) (pair address (pair address int)) + }; # list operation : @storage + }; # list operation : @storage + PAIR; # pair (list operation) @storage + }}; # operation : address : @storage + PAIR; # pair operation address : @storage + # sp.operations().push(create_contract_102.value.operation) # pair operation address : @storage + DUP; # pair operation address : pair operation address : @storage + CAR; # operation : pair operation address : @storage + NIL operation; # list operation : operation : pair operation address : @storage + SWAP; # operation : list operation : pair operation address : @storage + CONS; # list operation : pair operation address : @storage + # sp.transfer((create_contract_102.value.address, self.data.makeOvenOwner.open_some()), sp.tez(0), sp.contract(sp.TPair(sp.TAddress, sp.TAddress), self.data.ovenRegistryContractAddress, entry_point='addOven').open_some()) # list operation : pair operation address : @storage + DIG 2; # @storage : list operation : pair operation address + DUP; # @storage : @storage : list operation : pair operation address + DUG 3; # @storage : list operation : pair operation address : @storage + CDDAR; # address : list operation : pair operation address : @storage + CONTRACT %addOven (pair address address); # option (contract (pair address address)) : list operation : pair operation address : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : pair operation address : @storage + FAILWITH; # FAILED + }; # @some : list operation : pair operation address : @storage + PUSH mutez 0; # mutez : @some : list operation : pair operation address : @storage + DIG 4; # @storage : mutez : @some : list operation : pair operation address + DUP; # @storage : @storage : mutez : @some : list operation : pair operation address + DUG 5; # @storage : mutez : @some : list operation : pair operation address : @storage + CADDR; # option address : mutez : @some : list operation : pair operation address : @storage + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : pair operation address : @storage + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : pair operation address : @storage + DIG 4; # pair operation address : @some : mutez : @some : list operation : @storage + CDR; # address : @some : mutez : @some : list operation : @storage + PAIR; # pair address @some : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + SWAP; # @storage : list operation + # self.data.state = 0 # @storage : list operation + DUP; # @storage : @storage : list operation + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @storage : list operation + SWAP; # @storage : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + DUP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + CAR; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + SWAP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + CDAR; # address : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + PUSH int 0; # int : address : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + SWAP; # address : int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + PAIR; # pair address int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + SWAP; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair address int : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + PAIR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : list operation + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + PAIR; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : list operation + # self.data.makeOvenOwner = sp.none # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : list operation + DUP; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : list operation + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : list operation + SWAP; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + DUP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + CAR; # address : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + CDAR; # option key_hash : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + NONE address; # option address : option key_hash : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + SWAP; # option key_hash : option address : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + PAIR; # pair (option key_hash) (option address) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + SWAP; # address : pair (option key_hash) (option address) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + PAIR; # pair address (pair (option key_hash) (option address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int) : list operation + PAIR; # pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) : list operation + SWAP; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + } + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CAAR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @storage : @parameter%setGovernorContract + SWAP; # @storage : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setGovernorContract + CADR; # pair (option %initialDelegate key_hash) (option %makeOvenOwner address) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setGovernorContract + DIG 2; # @parameter%setGovernorContract : pair (option %initialDelegate key_hash) (option %makeOvenOwner address) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair @parameter%setGovernorContract (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair (pair @parameter%setGovernorContract (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + NIL operation; # list operation : pair (pair @parameter%setGovernorContract (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + }; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + }; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setInitialDelegate + # == setInitialDelegate == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setInitialDelegate + DUP; # @storage : @storage : @parameter%setInitialDelegate + DUG 2; # @storage : @parameter%setInitialDelegate : @storage + CAAR; # address : @parameter%setInitialDelegate : @storage + SENDER; # address : address : @parameter%setInitialDelegate : @storage + COMPARE; # int : @parameter%setInitialDelegate : @storage + EQ; # bool : @parameter%setInitialDelegate : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setInitialDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setInitialDelegate : @storage + SWAP; # @storage : @parameter%setInitialDelegate + # self.data.initialDelegate = params # @storage : @parameter%setInitialDelegate + DUP; # @storage : @storage : @parameter%setInitialDelegate + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @storage : @parameter%setInitialDelegate + SWAP; # @storage : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + DUP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + CAR; # address : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + CDDR; # option address : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : @parameter%setInitialDelegate + DIG 3; # @parameter%setInitialDelegate : option address : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair @parameter%setInitialDelegate (option address) : address : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + SWAP; # address : pair @parameter%setInitialDelegate (option address) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair address (pair @parameter%setInitialDelegate (option address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair (pair address (pair @parameter%setInitialDelegate (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + } + { + SWAP; # @storage : @parameter%setMinterContract + # == setMinterContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setMinterContract + DUP; # @storage : @storage : @parameter%setMinterContract + DUG 2; # @storage : @parameter%setMinterContract : @storage + CAAR; # address : @parameter%setMinterContract : @storage + SENDER; # address : address : @parameter%setMinterContract : @storage + COMPARE; # int : @parameter%setMinterContract : @storage + EQ; # bool : @parameter%setMinterContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setMinterContract : @storage + FAILWITH; # FAILED + }; # @parameter%setMinterContract : @storage + SWAP; # @storage : @parameter%setMinterContract + # self.data.minterContractAddress = params # @storage : @parameter%setMinterContract + DUP; # @storage : @storage : @parameter%setMinterContract + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @storage : @parameter%setMinterContract + SWAP; # @storage : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + DUP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + CDR; # pair (address %ovenRegistryContractAddress) (int %state) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + SWAP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + CADR; # address : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setMinterContract + DIG 3; # @parameter%setMinterContract : address : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair @parameter%setMinterContract address : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair (pair @parameter%setMinterContract address) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair @parameter%setMinterContract address) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair @parameter%setMinterContract address) (pair (address %ovenRegistryContractAddress) (int %state))) + }; # pair (pair address (pair @parameter%setInitialDelegate (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setOvenProxyContract + # == setOvenProxyContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOvenProxyContract + DUP; # @storage : @storage : @parameter%setOvenProxyContract + DUG 2; # @storage : @parameter%setOvenProxyContract : @storage + CAAR; # address : @parameter%setOvenProxyContract : @storage + SENDER; # address : address : @parameter%setOvenProxyContract : @storage + COMPARE; # int : @parameter%setOvenProxyContract : @storage + EQ; # bool : @parameter%setOvenProxyContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOvenProxyContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOvenProxyContract : @storage + SWAP; # @storage : @parameter%setOvenProxyContract + # self.data.ovenProxyContractAddress = params # @storage : @parameter%setOvenProxyContract + DUP; # @storage : @storage : @parameter%setOvenProxyContract + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @storage : @parameter%setOvenProxyContract + SWAP; # @storage : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + DUP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + CDR; # pair (address %ovenRegistryContractAddress) (int %state) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + SWAP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + CAAR; # address : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenProxyContract + DIG 3; # @parameter%setOvenProxyContract : address : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # address : @parameter%setOvenProxyContract : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair address @parameter%setOvenProxyContract : pair (address %ovenRegistryContractAddress) (int %state) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair (pair address @parameter%setOvenProxyContract) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair address @parameter%setOvenProxyContract) (pair (address %ovenRegistryContractAddress) (int %state)) + PAIR; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair address @parameter%setOvenProxyContract) (pair (address %ovenRegistryContractAddress) (int %state))) + } + { + SWAP; # @storage : @parameter%setOvenRegistryContract + # == setOvenRegistryContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + DUG 2; # @storage : @parameter%setOvenRegistryContract : @storage + CAAR; # address : @parameter%setOvenRegistryContract : @storage + SENDER; # address : address : @parameter%setOvenRegistryContract : @storage + COMPARE; # int : @parameter%setOvenRegistryContract : @storage + EQ; # bool : @parameter%setOvenRegistryContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOvenRegistryContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOvenRegistryContract : @storage + SWAP; # @storage : @parameter%setOvenRegistryContract + # self.data.ovenRegistryContractAddress = params # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + CAR; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @storage : @parameter%setOvenRegistryContract + SWAP; # @storage : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + CDR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + DUP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + CAR; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + SWAP; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state)) : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + CDDR; # int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : @parameter%setOvenRegistryContract + DIG 3; # @parameter%setOvenRegistryContract : int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair @parameter%setOvenRegistryContract int : pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %minterContractAddress) (address %ovenProxyContractAddress) : pair @parameter%setOvenRegistryContract int : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + PAIR; # pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair @parameter%setOvenRegistryContract int) : pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) + SWAP; # pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)) : pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair @parameter%setOvenRegistryContract int) + PAIR; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair @parameter%setOvenRegistryContract int)) + }; # pair (pair (address %governorContractAddress) (pair (option %initialDelegate key_hash) (option %makeOvenOwner address))) (pair (pair address @parameter%setOvenProxyContract) (pair (address %ovenRegistryContractAddress) (int %state))) + }; # pair (pair address (pair @parameter%setInitialDelegate (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + NIL operation; # list operation : pair (pair address (pair @parameter%setInitialDelegate (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair (address %ovenRegistryContractAddress) (int %state))) + }; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + NIL operation; # list operation : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + SWAP; # list operation : list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + ITER + { + CONS; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + }; # list operation : pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int)) + PAIR; # pair (list operation) (pair (pair address (pair (option key_hash) (option address))) (pair (pair (address %minterContractAddress) (address %ovenProxyContractAddress)) (pair address int))) + }; \ No newline at end of file diff --git a/smart_contracts/oven-proxy.py b/smart_contracts/oven-proxy.py new file mode 100644 index 00000000..095f2593 --- /dev/null +++ b/smart_contracts/oven-proxy.py @@ -0,0 +1,1967 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Errors = sp.import_script_from_url("file:common/errors.py") +OvenApi = sp.import_script_from_url("file:common/oven-api.py") + +################################################################ +# State Machine States. +################################################################ + +IDLE = 0 +BORROW_WAITING_FOR_ORACLE = 1 +WITHDRAW_WAITING_FOR_ORACLE = 2 +LIQUIDATE_WAITING_FOR_ORACLE = 3 + +################################################################ +# Contract +################################################################ + +class OvenProxyContract(sp.Contract): + def __init__( + self, + minterContractAddress = Addresses.MINTER_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ovenRegistryContractAddress = Addresses.OVEN_REGISTRY_ADDRESS, + pauseGuardianContractAddress = Addresses.PAUSE_GUARDIAN_ADDRESS, + oracleContractAddress = Addresses.ORACLE_ADDRESS, + paused = False, + state = IDLE + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + # Contract Addresses + minterContractAddress = minterContractAddress, + governorContractAddress = governorContractAddress, + ovenRegistryContractAddress = ovenRegistryContractAddress, + pauseGuardianContractAddress = pauseGuardianContractAddress, + oracleContractAddress = oracleContractAddress, + + # Pause Guardian + paused = paused, + + # State and registers + state = state, + borrowParams = sp.none, + withdrawParams = sp.none, + liquidateParams = sp.none + ) + + ################################################################ + # Public Interface + ################################################################ + + # Disallow direct transfers. + @sp.entry_point + def default(self, param): + sp.set_type(param, sp.TUnit) + sp.failwith(Errors.CANNOT_RECEIVE_FUNDS) + + ################################################################ + # Oven Interface + ################################################################ + + @sp.entry_point + def borrow(self, param): + sp.set_type(param, OvenApi.BORROW_PARAMETER_TYPE) + + self.verifyIsOven(sp.sender) + + # Verify system is not paused. + sp.verify(self.data.paused == False, message = Errors.PAUSED) + + # Verify in idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + # Update state and save params + self.data.state = BORROW_WAITING_FOR_ORACLE + self.data.borrowParams = sp.some(param) + + self.callOracleWithCallback('borrow_callback') + + @sp.entry_point + def borrow_callback(self, oracleResult): + sp.set_type(oracleResult, sp.TNat) + + # Verify sender is the oracle + sp.verify(sp.sender == self.data.oracleContractAddress, message = Errors.NOT_ORACLE) + + # Verify state + sp.verify(self.data.state == BORROW_WAITING_FOR_ORACLE, message = Errors.BAD_STATE) + + # Load borrow params + param = (oracleResult, self.data.borrowParams.open_some()) + minterContractHandle = sp.contract( + OvenApi.BORROW_PARAMETER_TYPE_ORACLE, + self.data.minterContractAddress, + OvenApi.BORROW_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.balance, minterContractHandle) + + # Reset state + self.data.state = IDLE + self.data.borrowParams = sp.none + + @sp.entry_point + def repay(self, param): + sp.set_type(param, OvenApi.REPAY_PARAMETER_TYPE) + + self.verifyIsOven(sp.sender) + + # Verify system is not paused. + sp.verify(self.data.paused == False, message = Errors.PAUSED) + + # Verify in idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + minterContractHandle = sp.contract( + OvenApi.REPAY_PARAMETER_TYPE, + self.data.minterContractAddress, + OvenApi.REPAY_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.amount, minterContractHandle) + + @sp.entry_point + def liquidate(self, param): + sp.set_type(param, OvenApi.LIQUIDATE_PARAMETER_TYPE) + self.verifyIsOven(sp.sender) + + # Verify system is not paused. + sp.verify(self.data.paused == False, message = Errors.PAUSED) + + # Verify in idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + # Update state and save params + self.data.state = LIQUIDATE_WAITING_FOR_ORACLE + self.data.liquidateParams = sp.some(param) + + self.callOracleWithCallback('liquidate_callback') + + @sp.entry_point + def liquidate_callback(self, oracleResult): + sp.set_type(oracleResult, sp.TNat) + + # Verify sender is the oracle + sp.verify(sp.sender == self.data.oracleContractAddress, message = Errors.NOT_ORACLE) + + # Verify state + sp.verify(self.data.state == LIQUIDATE_WAITING_FOR_ORACLE, message = Errors.BAD_STATE) + + # Load liquidate params + param = (oracleResult, self.data.liquidateParams.open_some()) + minterContractHandle = sp.contract( + OvenApi.LIQUIDATE_PARAMETER_TYPE_ORACLE, + self.data.minterContractAddress, + OvenApi.LIQUIDATE_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.balance, minterContractHandle) + + # Reset state + self.data.state = IDLE + self.data.liquidateParams = sp.none + + @sp.entry_point + def withdraw(self, param): + sp.set_type(param, OvenApi.WITHDRAW_PARAMETER_TYPE) + self.verifyIsOven(sp.sender) + + # Verify in idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + # Verify system is not paused. + sp.verify(self.data.paused == False, message = Errors.PAUSED) + + # Update state and save params + self.data.state = WITHDRAW_WAITING_FOR_ORACLE + self.data.withdrawParams = sp.some(param) + + self.callOracleWithCallback('withdraw_callback') + + @sp.entry_point + def withdraw_callback(self, oracleResult): + sp.set_type(oracleResult, sp.TNat) + + # Verify sender is the oracle + sp.verify(sp.sender == self.data.oracleContractAddress, message = Errors.NOT_ORACLE) + + # Verify state + sp.verify(self.data.state == WITHDRAW_WAITING_FOR_ORACLE, message = Errors.BAD_STATE) + + # Load withdraw params + param = (oracleResult, self.data.withdrawParams.open_some()) + minterContractHandle = sp.contract( + OvenApi.WITHDRAW_PARAMETER_TYPE_ORACLE, + self.data.minterContractAddress, + OvenApi.WITHDRAW_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.balance, minterContractHandle) + + # Reset state + self.data.state = IDLE + self.data.withdrawParams = sp.none + + @sp.entry_point + def deposit(self, param): + sp.set_type(param, OvenApi.DEPOSIT_PARAMETER_TYPE) + self.verifyIsOven(sp.sender) + + # Verify system is not paused. + sp.verify(self.data.paused == False, message = Errors.PAUSED) + + # Verify in idle state + sp.verify(self.data.state == IDLE, message = Errors.BAD_STATE) + + minterContractHandle = sp.contract( + OvenApi.DEPOSIT_PARAMETER_TYPE, + self.data.minterContractAddress, + OvenApi.DEPOSIT_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.amount, minterContractHandle) + + ################################################################ + # Minter Interface + ################################################################ + + @sp.entry_point + def updateState(self, param): + sp.set_type(param, OvenApi.UPDATE_STATE_PARAMETER_TYPE) + + # Verify input came from Minter and was addressed correctly. + sp.verify(sp.sender == self.data.minterContractAddress, message = Errors.NOT_MINTER) + + # Forward call to destination. + destination = sp.fst(param) + ovenHandle = sp.contract( + OvenApi.UPDATE_STATE_PARAMETER_TYPE, + destination, + OvenApi.UPDATE_STATE_ENTRY_POINT_NAME + ).open_some() + sp.transfer(param, sp.amount, ovenHandle) + + ################################################################ + # Pause Guardian + ################################################################ + + # Pause the system + @sp.entry_point + def pause(self): + sp.verify(sp.sender == self.data.pauseGuardianContractAddress, message = Errors.NOT_PAUSE_GUARDIAN) + self.data.paused = True + + ################################################################ + # Governance + ################################################################ + + # Unpause the system. + @sp.entry_point + def unpause(self): + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.paused = False + + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # Update the minter contract address. + @sp.entry_point + def setMinterContract(self, newMinterContractAddress): + sp.set_type(newMinterContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.minterContractAddress = newMinterContractAddress + + # Update the oven registry contract address. + @sp.entry_point + def setOvenRegistryContract(self, newOvenRegistryContractAddress): + sp.set_type(newOvenRegistryContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.ovenRegistryContractAddress = newOvenRegistryContractAddress + + # Update the oracle contract address. + @sp.entry_point + def setOracleContract(self, newOracleContractAddress): + sp.set_type(newOracleContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.oracleContractAddress = newOracleContractAddress + + # Update the pause guardian contract address. + @sp.entry_point + def setPauseGuardianContract(self, newPauseGuardianContract): + sp.set_type(newPauseGuardianContract, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.pauseGuardianContractAddress = newPauseGuardianContract + + ################################################################ + # Helpers + ################################################################ + + # Check if the given address is a known Oven. + def verifyIsOven(self, ovenAddress): + # Make a call to the oven registry. + contractHandle = sp.contract( + sp.TAddress, + self.data.ovenRegistryContractAddress, + "isOven" + ).open_some() + sp.transfer(ovenAddress, sp.mutez(0), contractHandle) + + def callOracleWithCallback(self, entrypoint): + # Call oracle + oracleCallback = sp.self_entry_point(entry_point = entrypoint) + oracleContractHandle = sp.contract( + sp.TContract(sp.TNat), + self.data.oracleContractAddress, + 'getXtzUsdRate' + ).open_some() + + sp.transfer(oracleCallback, sp.mutez(0), oracleContractHandle) + + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + MockMinter = sp.import_script_from_url("file:test-helpers/mock-minter.py") + Oven = sp.import_script_from_url("file:oven.py") + Oracle = sp.import_script_from_url("file:oracle.py") + OvenRegistry = sp.import_script_from_url("file:oven-registry.py") + FakeHarbinger = sp.import_script_from_url("file:test-helpers/fake-harbinger.py") + + ################################################################ + # withdraw + ################################################################ + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538@ + # sp.add_test(name="withdraw - fails when not called from oven") + # def test(): + # scenario = sp.test_scenario() + + # # AND a faked Oracle contract + # fakeHarbingerValue = sp.nat(8) + # harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + # scenario += harbinger + # oracle = Oracle.OracleContract( + # harbingerContractAddress = harbinger.address + # ) + # scenario += oracle + + # # GIVEN an OvenRegistry contract + # ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + # ovenRegistry = OvenRegistry.OvenRegistryContract( + # ovenFactoryContractAddress = ovenFactoryAddress + # ) + # scenario += ovenRegistry + + # # AND an oven which is registered + # ovenAddress = Addresses.OVEN_ADDRESS + # scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + # sender = ovenFactoryAddress + # ) + + # # AND a mock minter contract + # minter = MockMinter.MockMinterContract() + # scenario += minter + + # # AND an OvenProxy + # ovenProxy = OvenProxyContract( + # ovenRegistryContractAddress = ovenRegistry.address, + # minterContractAddress = minter.address, + # oracleContractAddress = oracle.address + # ) + # scenario += ovenProxy + + + # scenario += ovenRegistry.isOven(ovenAddress) + # scenario += ovenRegistry.isOven(ovenFactoryAddress).run( + # valid = False + # ) + + # # WHEN withdraw is called by someone other than an oven THEN the call fails. + # ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + # ovenBalance = sp.nat(1) + # borrowedTokens = sp.nat(2) + # isLiquidated = False + # stabilityFeeTokens = sp.int(3) + # interestIndex = sp.int(4) + # mutezToWithdraw = sp.mutez(5) + # param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, mutezToWithdraw))))))) + # amount = sp.mutez(1) + # scenario += ovenProxy.withdraw(param).run( + # sender = ovenFactoryAddress, + # amount = amount, + # valid = False + # ) + + @sp.add_test(name="withdraw - fails when paused") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy which is paused + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + paused = True + ) + scenario += ovenProxy + + # WHEN withdraw is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + mutezToWithdraw = sp.mutez(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, mutezToWithdraw))))))) + amount = sp.mutez(1) + scenario += ovenProxy.withdraw(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="withdraw - fails when in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE_STATE state + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN withdraw is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + mutezToWithdraw = sp.mutez(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, mutezToWithdraw))))))) + amount = sp.mutez(1) + scenario += ovenProxy.withdraw(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="withdraw - passes withdraw params") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address + ) + scenario += ovenProxy + + # WHEN withdraw is called by an oven + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + mutezToWithdraw = sp.mutez(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, mutezToWithdraw))))))) + amount = sp.mutez(1) + scenario += ovenProxy.withdraw(param).run( + sender = ovenAddress, + amount = amount, + now = sp.timestamp_from_utc_now() + ) + + # THEN the minter contract receives the parameters + scenario.verify(minter.data.withdraw_ovenAddress == ovenAddress) + scenario.verify(minter.data.withdraw_ownerAddress == ownerAddress) + scenario.verify(minter.data.withdraw_ovenBalance == ovenBalance) + scenario.verify(minter.data.withdraw_borrowedTokens == borrowedTokens) + scenario.verify(minter.data.withdraw_liquidated == isLiquidated) + scenario.verify(minter.data.withdraw_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(minter.data.withdraw_ovenInterestIndex == interestIndex) + scenario.verify(minter.data.withdraw_mutezToWithdraw == mutezToWithdraw) + + # AND the balance of the minter is the balance sent. + scenario.verify(minter.balance == sp.mutez(1)) + + ################################################################ + # liquidate + ################################################################ + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538# + # @sp.add_test(name="liquidate - fails when not called from oven") + # def test(): + # scenario = sp.test_scenario() + + # # GIVEN an OvenRegistry contract + # ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + # ovenRegistry = OvenRegistry.OvenRegistryContract( + # ovenFactoryContractAddress = ovenFactoryAddress + # ) + # scenario += ovenRegistry + + # # AND an oven which is registered + # ovenAddress = Addresses.OVEN_ADDRESS + # scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + # sender = ovenFactoryAddress + # ) + + # # AND a mock minter contract + # minter = MockMinter.MockMinterContract() + # scenario += minter + + # # AND a faked Oracle contract + # fakeHarbingerValue = sp.nat(8) + # harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + # scenario += harbinger + # oracle = Oracle.OracleContract( + # harbingerContractAddress = harbinger.address + # ) + # scenario += oracle + + # # AND an OvenProxy + # ovenProxy = OvenProxyContract( + # ovenRegistryContractAddress = ovenRegistry.address, + # minterContractAddress = minter.address, + # oracleContractAddress = oracle.address + # ) + # scenario += ovenProxy + + # # WHEN borrow is called by someone other than an oven THEN the call fails. + # ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + # ovenBalance = sp.nat(1) + # borrowedTokens = sp.nat(2) + # isLiquidated = False + # stabilityFeeTokens = sp.int(3) + # interestIndex = sp.int(4) + # liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + # param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress))))))) + # amount = sp.mutez(1) + # scenario += ovenProxy.liquidate(param).run( + # sender = ownerAddress, + # amount = amount, + # valid = False + # ) + + @sp.add_test(name="liquidate - fails when paused") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy which is paused + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + paused = True + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress))))))) + amount = sp.mutez(1) + scenario += ovenProxy.liquidate(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="liquidate - fails when in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE_STATE state + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress))))))) + amount = sp.mutez(1) + scenario += ovenProxy.liquidate(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="liquidate - passes liquidate params") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, liquidatorAddress))))))) + amount = sp.mutez(1) + scenario += ovenProxy.liquidate(param).run( + sender = ovenAddress, + amount = amount, + now = sp.timestamp_from_utc_now() + ) + + # THEN the minter contract receives the parameters + scenario.verify(minter.data.liquidate_ovenAddress == ovenAddress) + scenario.verify(minter.data.liquidate_ownerAddress == ownerAddress) + scenario.verify(minter.data.liquidate_ovenBalance == ovenBalance) + scenario.verify(minter.data.liquidate_borrowedTokens == borrowedTokens) + scenario.verify(minter.data.liquidate_liquidated == isLiquidated) + scenario.verify(minter.data.liquidate_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(minter.data.liquidate_ovenInterestIndex == interestIndex) + scenario.verify(minter.data.liquidate_liquidatorAddress == liquidatorAddress) + + # AND the balance of the minter is the balance sent. + scenario.verify(minter.balance == sp.mutez(1)) + + ################################################################ + # borrow + ################################################################ + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538 + # @sp.add_test(name="borrow - fails when not called from oven") + # def test(): + # scenario = sp.test_scenario() + + # # GIVEN an OvenRegistry contract + # ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + # ovenRegistry = OvenRegistry.OvenRegistryContract( + # ovenFactoryContractAddress = ovenFactoryAddress + # ) + # scenario += ovenRegistry + + # # AND an oven which is registered + # ovenAddress = Addresses.OVEN_ADDRESS + # scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + # sender = ovenFactoryAddress + # ) + + # # AND a mock minter contract + # minter = MockMinter.MockMinterContract() + # scenario += minter + + # # AND a faked Oracle contract + # fakeHarbingerValue = sp.nat(8) + # harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + # scenario += harbinger + # oracle = Oracle.OracleContract( + # harbingerContractAddress = harbinger.address + # ) + # scenario += oracle + + # # AND an OvenProxy + # ovenProxy = OvenProxyContract( + # ovenRegistryContractAddress = ovenRegistry.address, + # minterContractAddress = minter.address, + # oracleContractAddress = oracle.address + # ) + # scenario += ovenProxy + + # # WHEN borrow is called by someone other than an oven THEN the call fails. + # ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + # ovenBalance = sp.nat(1) + # borrowedTokens = sp.nat(2) + # isLiquidated = False + # stabilityFeeTokens = sp.int(3) + # interestIndex = sp.int(4) + # tokensToBorrow = sp.nat(5) + # param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow))))))) + # amount = sp.mutez(1) + # scenario += ovenProxy.borrow(param).run( + # sender = ownerAddress, + # amount = amount, + # valid = False + # ) + + @sp.add_test(name="borrow - fails when paused") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy which is paused + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + paused = True + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToBorrow = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow))))))) + amount = sp.mutez(1) + scenario += ovenProxy.borrow(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="borrow - fails when in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE_STATE state + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToBorrow = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow))))))) + amount = sp.mutez(1) + scenario += ovenProxy.borrow(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="borrow - passes borrow params") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND a faked Oracle contract + fakeHarbingerValue = sp.nat(8) + harbinger = FakeHarbinger.FakeHarbingerContract(fakeHarbingerValue, sp.timestamp_from_utc_now(), "XTZ-USD") + scenario += harbinger + oracle = Oracle.OracleContract( + harbingerContractAddress = harbinger.address + ) + scenario += oracle + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + oracleContractAddress = oracle.address + ) + scenario += ovenProxy + + # WHEN borrow is called by an oven + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToBorrow = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToBorrow))))))) + amount = sp.mutez(1) + scenario += ovenProxy.borrow(param).run( + sender = ovenAddress, + amount = amount, + now = sp.timestamp_from_utc_now() + ) + + # THEN the minter contract receives the parameters + scenario.verify(minter.data.borrow_ovenAddress == ovenAddress) + scenario.verify(minter.data.borrow_ownerAddress == ownerAddress) + scenario.verify(minter.data.borrow_ovenBalance == ovenBalance) + scenario.verify(minter.data.borrow_borrowedTokens == borrowedTokens) + scenario.verify(minter.data.borrow_liquidated == isLiquidated) + scenario.verify(minter.data.borrow_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(minter.data.borrow_ovenInterestIndex == interestIndex) + scenario.verify(minter.data.borrow_tokensToBorrow == tokensToBorrow) + + # AND the balance of the minter is the balance sent. + scenario.verify(minter.balance == sp.mutez(1)) + + ################################################################ + # borrow_callback + ################################################################ + + @sp.add_test(name="borrow_callback - fails in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the IDLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = IDLE + ) + scenario += ovenProxy + + # WHEN borrow_callback is called THEN the call fails + callbackValue = sp.nat(2) + scenario += ovenProxy.borrow_callback(callbackValue).run( + sender = oracleAddress, + valid = False + ) + + @sp.add_test(name="borrow_callback - fails with bad sender") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN borrow_callback is called by someone other than the oracle THEN the call fails + callbackValue = sp.nat(2) + notOracleAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + scenario += ovenProxy.borrow_callback(callbackValue).run( + sender = notOracleAddress, + valid = False + ) + + ################################################################ + # liquidate_callback + ################################################################ + + @sp.add_test(name="liquidate_callback - fails in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the IDLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = IDLE + ) + scenario += ovenProxy + + # WHEN liquidate_callback is called THEN the call fails + callbackValue = sp.nat(2) + scenario += ovenProxy.liquidate_callback(callbackValue).run( + sender = oracleAddress, + valid = False + ) + + @sp.add_test(name="liquidate_callback - fails with bad sender") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the LIQUIDATE_WAITING_FOR_ORACLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = LIQUIDATE_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN liquidate_callback is called by someone other than the oracle THEN the call fails + callbackValue = sp.nat(2) + notOracleAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + scenario += ovenProxy.liquidate_callback(callbackValue).run( + sender = notOracleAddress, + valid = False + ) + + ################################################################ + # withdraw_callback + ################################################################ + + @sp.add_test(name="withdraw_callback - fails in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the IDLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = IDLE + ) + scenario += ovenProxy + + # WHEN withdraw_callback is called THEN the call fails + callbackValue = sp.nat(2) + scenario += ovenProxy.withdraw_callback(callbackValue).run( + sender = oracleAddress, + valid = False + ) + + @sp.add_test(name="withdraw_callback - fails with bad sender") + def test(): + scenario = sp.test_scenario() + + # GIVEN a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an Oracle contract + oracleAddress = Addresses.ORACLE_ADDRESS + + # AND an OvenProxy in the WITHDRAW_WAITING_FOR_ORACLE state + ovenProxy = OvenProxyContract( + minterContractAddress = minter.address, + oracleContractAddress = oracleAddress, + state = WITHDRAW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN withdraw_callback is called by someone other than the oracle THEN the call fails + callbackValue = sp.nat(2) + notOracleAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + scenario += ovenProxy.withdraw_callback(callbackValue).run( + sender = notOracleAddress, + valid = False + ) + + ################################################################ + # repay + ################################################################ + + @sp.add_test(name="repay - fails when not sent from oven") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + paused = True + ) + scenario += ovenProxy + + # WHEN repay is called by someone other than an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToRepay = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + amount = sp.mutez(1) + scenario += ovenProxy.repay(param).run( + sender = ownerAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="repay - fails when paused") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy which is paused + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + paused = True + ) + scenario += ovenProxy + + # WHEN repay is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToRepay = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + amount = sp.mutez(1) + scenario += ovenProxy.repay(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="repay - fails when in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE state + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN repay is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToRepay = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + amount = sp.mutez(1) + scenario += ovenProxy.repay(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="repay - passes repay params") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address + ) + scenario += ovenProxy + + # WHEN repay is called by an oven + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + tokensToRepay = sp.nat(5) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex, tokensToRepay))))))) + amount = sp.mutez(1) + scenario += ovenProxy.repay(param).run( + sender = ovenAddress, + amount = amount + ) + + # THEN the minter contract receives the parameters + scenario.verify(minter.data.repay_ovenAddress == ovenAddress) + scenario.verify(minter.data.repay_ownerAddress == ownerAddress) + scenario.verify(minter.data.repay_ovenBalance == ovenBalance) + scenario.verify(minter.data.repay_borrowedTokens == borrowedTokens) + scenario.verify(minter.data.repay_liquidated == isLiquidated) + scenario.verify(minter.data.repay_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(minter.data.repay_ovenInterestIndex == interestIndex) + scenario.verify(minter.data.repay_tokensToRepay == tokensToRepay) + + # AND the balance of the minter is the balance sent. + scenario.verify(minter.balance == sp.mutez(1)) + + ################################################################ + # deposit + ################################################################ + + @sp.add_test(name="deposit - fails when not sent from oven") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + paused = True + ) + scenario += ovenProxy + + # WHEN deposit is called by someone other than an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex))))))) + amount = sp.mutez(1) + scenario += ovenProxy.deposit(param).run( + sender = ownerAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="deposit - fails when paused") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy which is paused + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + paused = True + ) + scenario += ovenProxy + + # WHEN deposit is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex))))))) + amount = sp.mutez(1) + scenario += ovenProxy.deposit(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="deposit - fails when in bad state") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy in the BORROW_WAITING_FOR_ORACLE state + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address, + state = BORROW_WAITING_FOR_ORACLE + ) + scenario += ovenProxy + + # WHEN deposit is called by an oven THEN the call fails. + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex))))))) + amount = sp.mutez(1) + scenario += ovenProxy.deposit(param).run( + sender = ovenAddress, + amount = amount, + valid = False + ) + + @sp.add_test(name="deposit - passes deposit") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a mock minter contract + minter = MockMinter.MockMinterContract() + scenario += minter + + # AND an OvenProxy + ovenProxy = OvenProxyContract( + ovenRegistryContractAddress = ovenRegistry.address, + minterContractAddress = minter.address + ) + scenario += ovenProxy + + # WHEN deposit is called by an oven + ownerAddress = sp.address("tz1YfB2H1NoZVUq4heHqrVX4oVp99yz8gwNq") + ovenBalance = sp.nat(1) + borrowedTokens = sp.nat(2) + isLiquidated = False + stabilityFeeTokens = sp.int(3) + interestIndex = sp.int(4) + param = (ovenAddress, (ownerAddress, (ovenBalance, (borrowedTokens, (isLiquidated, (stabilityFeeTokens, (interestIndex))))))) + amount = sp.mutez(1) + scenario += ovenProxy.deposit(param).run( + sender = ovenAddress, + amount = amount + ) + + # THEN the minter contract receives the parameters + scenario.verify(minter.data.deposit_ovenAddress == ovenAddress) + scenario.verify(minter.data.deposit_ownerAddress == ownerAddress) + scenario.verify(minter.data.deposit_ovenBalance == ovenBalance) + scenario.verify(minter.data.deposit_borrowedTokens == borrowedTokens) + scenario.verify(minter.data.deposit_liquidated == isLiquidated) + scenario.verify(minter.data.deposit_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(minter.data.deposit_ovenInterestIndex == interestIndex) + + # AND the balance of the minter is the balance sent. + scenario.verify(minter.balance == sp.mutez(1)) + + ################################################################ + # updateState + ################################################################ + + @sp.add_test(name="updateState - successfully forwards update") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + minterContractAddress = Addresses.MINTER_ADDRESS + ovenProxy = OvenProxyContract( + minterContractAddress = minterContractAddress, + ) + scenario += ovenProxy + + # AND an Oven contract. + oven = Oven.OvenContract( + ovenProxyContractAddress = ovenProxy.address + ) + scenario += oven + + # WHEN updateState is called by the minter + newBorrowedTokens = 1 + newStabilityFees = 2 + newInterestIndex = 3 + newIsLiquidated = True + update = (oven.address, (newBorrowedTokens, (newStabilityFees, (newInterestIndex, newIsLiquidated)))) + scenario += ovenProxy.updateState(update).run( + sender = minterContractAddress, + ) + + # THEN the call is correctly forwarded to the Oven. + scenario.verify(oven.data.borrowedTokens == newBorrowedTokens) + scenario.verify(oven.data.stabilityFeeTokens == newStabilityFees) + scenario.verify(oven.data.interestIndex == newInterestIndex) + scenario.verify(oven.data.isLiquidated == newIsLiquidated) + + @sp.add_test(name="updateState - fails when not called by minter") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + minterContractAddress = Addresses.MINTER_ADDRESS + ovenProxy = OvenProxyContract( + minterContractAddress = minterContractAddress, + ) + scenario += ovenProxy + + # WHEN updateState is called by someone who isn't the minter THEN the call fails + notMinter = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + update = (notMinter, (1, (-2, (-3, True)))) + scenario += ovenProxy.updateState(update).run( + sender = notMinter, + valid = False + ) + + ################################################################ + # pause + ################################################################ + + @sp.add_test(name="pause - succeeds when called by pause guardian") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + pauseGuardianContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + pauseGuardianContractAddress = pauseGuardianContractAddress, + paused = False + ) + scenario += ovenProxy + + # WHEN pause is called + scenario += ovenProxy.pause(sp.unit).run( + sender = pauseGuardianContractAddress + ) + + # THEN the contract is paused + scenario.verify(ovenProxy.data.paused == True) + + @sp.add_test(name="pause - fails when not called by pause guardian") + def test(): + # GIVEN an OvenProxy contract which is paused + scenario = sp.test_scenario() + + pauseGuardianContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + pauseGuardianContractAddress = pauseGuardianContractAddress, + paused = True + ) + scenario += ovenProxy + + # WHEN pause is called by someone who isn't the pause guardian THEN the call fails + notPauseGuardian = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.pause(sp.unit).run( + sender = notPauseGuardian, + valid = False + ) + + ################################################################ + # unpause + ################################################################ + + @sp.add_test(name="unpause - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract which is paused + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress, + paused = True + ) + scenario += ovenProxy + + # WHEN unpause is called + scenario += ovenProxy.unpause(sp.unit).run( + sender = governorContractAddress + ) + + # THEN the contract is no longer paused. + scenario.verify(ovenProxy.data.paused == False) + + @sp.add_test(name="unpause - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract which is paused + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress, + paused = True + ) + scenario += ovenProxy + + # WHEN unpause is called by someone who isn't the governor THEN the call fails + notGovernor = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.unpause(sp.unit).run( + sender = notGovernor, + valid = False + ) + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setGovernorContract is called with a new contract + newContractAddress= sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setGovernorContract(newContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenProxy.data.governorContractAddress == newContractAddress) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + newContractAddress = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setGovernorContract(newContractAddress).run( + sender = newContractAddress, + valid = False + ) + + ################################################################ + # setMinterContract + ################################################################ + + @sp.add_test(name="setMinterContract - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setMinterContract is called with a new contract + newContractAddress= sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setMinterContract(newContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenProxy.data.minterContractAddress == newContractAddress) + + @sp.add_test(name="setMinterContract - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setMinterContract is called by someone who isn't the governor THEN the call fails + newContractAddress = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setMinterContract(newContractAddress).run( + sender = newContractAddress, + valid = False + ) + + ################################################################ + # setOvenRegistryContract + ################################################################ + + @sp.add_test(name="setOvenRegistryContract - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setOvenRegistryContract is called with a new contract + newContractAddress= sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setOvenRegistryContract(newContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenProxy.data.ovenRegistryContractAddress == newContractAddress) + + @sp.add_test(name="setOvenRegistryContract - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setOvenRegistryContract is called by someone who isn't the governor THEN the call fails + newContractAddress = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setOvenRegistryContract(newContractAddress).run( + sender = newContractAddress, + valid = False + ) + + ################################################################ + # setOracleContract + ################################################################ + + @sp.add_test(name="setOracleContract - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setOracleContract is called with a new contract + newContractAddress= sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setOracleContract(newContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenProxy.data.oracleContractAddress == newContractAddress) + + @sp.add_test(name="setOracleContract - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setOracleContract is called by someone who isn't the governor THEN the call fails + newContractAddress = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setOracleContract(newContractAddress).run( + sender = newContractAddress, + valid = False + ) + + ################################################################ + # setPauseGuardian + ################################################################ + + @sp.add_test(name="setPauseGuardianContract - succeeds when called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setPauseGuardianContract is called with a new contract + newContractAddress= sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setPauseGuardianContract(newContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(ovenProxy.data.pauseGuardianContractAddress == newContractAddress) + + @sp.add_test(name="setPauseGuardianContract - fails when not called by governor") + def test(): + # GIVEN an OvenProxy contract + scenario = sp.test_scenario() + + governorContractAddress = sp.address("tz1harbiBBB9smBiDY7fV6DYpVm5aZD7HT98") + ovenProxy = OvenProxyContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenProxy + + # WHEN the setPauseGuardianContract is called by someone who isn't the governor THEN the call fails + newContractAddress = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + scenario += ovenProxy.setPauseGuardianContract(newContractAddress).run( + sender = newContractAddress, + valid = False + ) \ No newline at end of file diff --git a/smart_contracts/oven-proxy.tz b/smart_contracts/oven-proxy.tz new file mode 100644 index 00000000..6cee3d52 --- /dev/null +++ b/smart_contracts/oven-proxy.tz @@ -0,0 +1,1068 @@ +parameter (or (or (or (or (pair %borrow address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) (nat %borrow_callback)) (or (unit %default) (pair %deposit address (pair address (pair nat (pair nat (pair bool (pair int int)))))))) (or (or (pair %liquidate address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) (nat %liquidate_callback)) (or (unit %pause) (pair %repay address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))))) (or (or (or (address %setGovernorContract) (address %setMinterContract)) (or (address %setOracleContract) (address %setOvenRegistryContract))) (or (or (address %setPauseGuardianContract) (unit %unpause)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (or (pair %withdraw address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) (nat %withdraw_callback)))))); +storage (pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + # == borrow == + # sp.transfer(sp.sender, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%borrow : @storage + NIL operation; # list operation : @parameter%borrow : @storage + DIG 2; # @storage : list operation : @parameter%borrow + DUP; # @storage : @storage : list operation : @parameter%borrow + DUG 3; # @storage : list operation : @parameter%borrow : @storage + CDAAR; # address : list operation : @parameter%borrow : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%borrow : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%borrow : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%borrow : @storage + SENDER; # address : mutez : @some : list operation : @parameter%borrow : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%borrow : @storage + CONS; # list operation : @parameter%borrow : @storage + # sp.verify(self.data.paused == False, message = 18) # list operation : @parameter%borrow : @storage + PUSH bool False; # bool : list operation : @parameter%borrow : @storage + DIG 3; # @storage : bool : list operation : @parameter%borrow + DUP; # @storage : @storage : bool : list operation : @parameter%borrow + DUG 4; # @storage : bool : list operation : @parameter%borrow : @storage + CDDAR; # bool : bool : list operation : @parameter%borrow : @storage + COMPARE; # int : list operation : @parameter%borrow : @storage + EQ; # bool : list operation : @parameter%borrow : @storage + IF + {} + { + PUSH int 18; # int : list operation : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%borrow : @storage + # sp.verify(self.data.state == 0, message = 12) # list operation : @parameter%borrow : @storage + PUSH int 0; # int : list operation : @parameter%borrow : @storage + DIG 3; # @storage : int : list operation : @parameter%borrow + DUP; # @storage : @storage : int : list operation : @parameter%borrow + DUG 4; # @storage : int : list operation : @parameter%borrow : @storage + CDDDAR; # int : int : list operation : @parameter%borrow : @storage + COMPARE; # int : list operation : @parameter%borrow : @storage + EQ; # bool : list operation : @parameter%borrow : @storage + IF + {} + { + PUSH int 12; # int : list operation : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%borrow : @storage + # self.data.state = 1 # list operation : @parameter%borrow : @storage + DIG 2; # @storage : list operation : @parameter%borrow + DUP; # @storage : @storage : list operation : @parameter%borrow + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation : @parameter%borrow + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + PUSH int 1; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%borrow + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%borrow + # self.data.borrowParams = sp.some(params) # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%borrow + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%borrow + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%borrow + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + CDR; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + CADR; # address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%borrow + DIG 4; # @parameter%borrow : address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SOME; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # sp.transfer(sp.self_entry_point('borrow_callback'), sp.tez(0), sp.contract(sp.TContract(sp.TNat), self.data.oracleContractAddress, entry_point='getXtzUsdRate').open_some()) # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUG 2; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CADDDR; # address : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONTRACT %getXtzUsdRate (contract nat); # option (contract (contract nat)) : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + IF_SOME + {} + { + UNIT; # unit : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + FAILWITH; # FAILED + }; # @some : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + PUSH mutez 0; # mutez : @some : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + SELF %borrow_callback; # contract nat : mutez : @some : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + TRANSFER_TOKENS; # operation : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONS; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + SWAP; # @storage : @parameter%borrow_callback + # == borrow_callback == + # sp.verify(sp.sender == self.data.oracleContractAddress, message = 3) # @storage : @parameter%borrow_callback + DUP; # @storage : @storage : @parameter%borrow_callback + DUG 2; # @storage : @parameter%borrow_callback : @storage + CADDDR; # address : @parameter%borrow_callback : @storage + SENDER; # address : address : @parameter%borrow_callback : @storage + COMPARE; # int : @parameter%borrow_callback : @storage + EQ; # bool : @parameter%borrow_callback : @storage + IF + {} + { + PUSH int 3; # int : @parameter%borrow_callback : @storage + FAILWITH; # FAILED + }; # @parameter%borrow_callback : @storage + # sp.verify(self.data.state == 1, message = 12) # @parameter%borrow_callback : @storage + PUSH int 1; # int : @parameter%borrow_callback : @storage + DIG 2; # @storage : int : @parameter%borrow_callback + DUP; # @storage : @storage : int : @parameter%borrow_callback + DUG 3; # @storage : int : @parameter%borrow_callback : @storage + CDDDAR; # int : int : @parameter%borrow_callback : @storage + COMPARE; # int : @parameter%borrow_callback : @storage + EQ; # bool : @parameter%borrow_callback : @storage + IF + {} + { + PUSH int 12; # int : @parameter%borrow_callback : @storage + FAILWITH; # FAILED + }; # @parameter%borrow_callback : @storage + # sp.transfer((params, self.data.borrowParams.open_some()), sp.balance, sp.contract(sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat)))))))), self.data.minterContractAddress, entry_point='borrow').open_some()) # @parameter%borrow_callback : @storage + NIL operation; # list operation : @parameter%borrow_callback : @storage + DIG 2; # @storage : list operation : @parameter%borrow_callback + DUP; # @storage : @storage : list operation : @parameter%borrow_callback + DUG 3; # @storage : list operation : @parameter%borrow_callback : @storage + CADDAR; # address : list operation : @parameter%borrow_callback : @storage + CONTRACT %borrow (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))); # option (contract (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))))) : list operation : @parameter%borrow_callback : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%borrow_callback : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%borrow_callback : @storage + BALANCE; # mutez : @some : list operation : @parameter%borrow_callback : @storage + DIG 4; # @storage : mutez : @some : list operation : @parameter%borrow_callback + DUP; # @storage : @storage : mutez : @some : list operation : @parameter%borrow_callback + DUG 5; # @storage : mutez : @some : list operation : @parameter%borrow_callback : @storage + CAAAR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : mutez : @some : list operation : @parameter%borrow_callback : @storage + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : @parameter%borrow_callback : @storage + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : @parameter%borrow_callback : @storage + DIG 4; # @parameter%borrow_callback : @some : mutez : @some : list operation : @storage + PAIR; # pair @parameter%borrow_callback @some : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + SWAP; # @storage : list operation + # self.data.state = 0 # @storage : list operation + DUP; # @storage : @storage : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PUSH int 0; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # self.data.borrowParams = sp.none # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CDR; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CADR; # address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + NONE (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + PUSH int 19; # int : @parameter%default : @storage + FAILWITH; # FAILED + } + { + # == deposit == + # sp.transfer(sp.sender, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%deposit : @storage + NIL operation; # list operation : @parameter%deposit : @storage + DIG 2; # @storage : list operation : @parameter%deposit + DUP; # @storage : @storage : list operation : @parameter%deposit + DUG 3; # @storage : list operation : @parameter%deposit : @storage + CDAAR; # address : list operation : @parameter%deposit : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%deposit : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%deposit : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%deposit : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%deposit : @storage + SENDER; # address : mutez : @some : list operation : @parameter%deposit : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%deposit : @storage + CONS; # list operation : @parameter%deposit : @storage + # sp.verify(self.data.paused == False, message = 18) # list operation : @parameter%deposit : @storage + PUSH bool False; # bool : list operation : @parameter%deposit : @storage + DIG 3; # @storage : bool : list operation : @parameter%deposit + DUP; # @storage : @storage : bool : list operation : @parameter%deposit + DUG 4; # @storage : bool : list operation : @parameter%deposit : @storage + CDDAR; # bool : bool : list operation : @parameter%deposit : @storage + COMPARE; # int : list operation : @parameter%deposit : @storage + EQ; # bool : list operation : @parameter%deposit : @storage + IF + {} + { + PUSH int 18; # int : list operation : @parameter%deposit : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%deposit : @storage + # sp.verify(self.data.state == 0, message = 12) # list operation : @parameter%deposit : @storage + PUSH int 0; # int : list operation : @parameter%deposit : @storage + DIG 3; # @storage : int : list operation : @parameter%deposit + DUP; # @storage : @storage : int : list operation : @parameter%deposit + DUG 4; # @storage : int : list operation : @parameter%deposit : @storage + CDDDAR; # int : int : list operation : @parameter%deposit : @storage + COMPARE; # int : list operation : @parameter%deposit : @storage + EQ; # bool : list operation : @parameter%deposit : @storage + IF + {} + { + PUSH int 12; # int : list operation : @parameter%deposit : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%deposit : @storage + # sp.transfer(params, sp.amount, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TInt)))))), self.data.minterContractAddress, entry_point='deposit').open_some()) # list operation : @parameter%deposit : @storage + DIG 2; # @storage : list operation : @parameter%deposit + DUP; # @storage : @storage : list operation : @parameter%deposit + DUG 3; # @storage : list operation : @parameter%deposit : @storage + CADDAR; # address : list operation : @parameter%deposit : @storage + CONTRACT %deposit (pair address (pair address (pair nat (pair nat (pair bool (pair int int)))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int int))))))) : list operation : @parameter%deposit : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%deposit : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%deposit : @storage + AMOUNT; # mutez : @some : list operation : @parameter%deposit : @storage + DIG 3; # @parameter%deposit : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + IF_LEFT + { + # == liquidate == + # sp.transfer(sp.sender, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%liquidate : @storage + NIL operation; # list operation : @parameter%liquidate : @storage + DIG 2; # @storage : list operation : @parameter%liquidate + DUP; # @storage : @storage : list operation : @parameter%liquidate + DUG 3; # @storage : list operation : @parameter%liquidate : @storage + CDAAR; # address : list operation : @parameter%liquidate : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%liquidate : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%liquidate : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%liquidate : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%liquidate : @storage + SENDER; # address : mutez : @some : list operation : @parameter%liquidate : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%liquidate : @storage + CONS; # list operation : @parameter%liquidate : @storage + # sp.verify(self.data.paused == False, message = 18) # list operation : @parameter%liquidate : @storage + PUSH bool False; # bool : list operation : @parameter%liquidate : @storage + DIG 3; # @storage : bool : list operation : @parameter%liquidate + DUP; # @storage : @storage : bool : list operation : @parameter%liquidate + DUG 4; # @storage : bool : list operation : @parameter%liquidate : @storage + CDDAR; # bool : bool : list operation : @parameter%liquidate : @storage + COMPARE; # int : list operation : @parameter%liquidate : @storage + EQ; # bool : list operation : @parameter%liquidate : @storage + IF + {} + { + PUSH int 18; # int : list operation : @parameter%liquidate : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%liquidate : @storage + # sp.verify(self.data.state == 0, message = 12) # list operation : @parameter%liquidate : @storage + PUSH int 0; # int : list operation : @parameter%liquidate : @storage + DIG 3; # @storage : int : list operation : @parameter%liquidate + DUP; # @storage : @storage : int : list operation : @parameter%liquidate + DUG 4; # @storage : int : list operation : @parameter%liquidate : @storage + CDDDAR; # int : int : list operation : @parameter%liquidate : @storage + COMPARE; # int : list operation : @parameter%liquidate : @storage + EQ; # bool : list operation : @parameter%liquidate : @storage + IF + {} + { + PUSH int 12; # int : list operation : @parameter%liquidate : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%liquidate : @storage + # self.data.state = 3 # list operation : @parameter%liquidate : @storage + DIG 2; # @storage : list operation : @parameter%liquidate + DUP; # @storage : @storage : list operation : @parameter%liquidate + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation : @parameter%liquidate + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + PUSH int 3; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%liquidate + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%liquidate + # self.data.liquidateParams = sp.some(params) # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%liquidate + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%liquidate + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%liquidate + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + CAR; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + CDDR; # pair (address %minterContractAddress) (address %oracleContractAddress) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%liquidate + DIG 4; # @parameter%liquidate : pair (address %minterContractAddress) (address %oracleContractAddress) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SOME; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (address %minterContractAddress) (address %oracleContractAddress) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SWAP; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # sp.transfer(sp.self_entry_point('liquidate_callback'), sp.tez(0), sp.contract(sp.TContract(sp.TNat), self.data.oracleContractAddress, entry_point='getXtzUsdRate').open_some()) # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUG 2; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CADDDR; # address : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONTRACT %getXtzUsdRate (contract nat); # option (contract (contract nat)) : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + IF_SOME + {} + { + UNIT; # unit : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + FAILWITH; # FAILED + }; # @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + PUSH mutez 0; # mutez : @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + SELF %liquidate_callback; # contract nat : mutez : @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + TRANSFER_TOKENS; # operation : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONS; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + SWAP; # @storage : @parameter%liquidate_callback + # == liquidate_callback == + # sp.verify(sp.sender == self.data.oracleContractAddress, message = 3) # @storage : @parameter%liquidate_callback + DUP; # @storage : @storage : @parameter%liquidate_callback + DUG 2; # @storage : @parameter%liquidate_callback : @storage + CADDDR; # address : @parameter%liquidate_callback : @storage + SENDER; # address : address : @parameter%liquidate_callback : @storage + COMPARE; # int : @parameter%liquidate_callback : @storage + EQ; # bool : @parameter%liquidate_callback : @storage + IF + {} + { + PUSH int 3; # int : @parameter%liquidate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%liquidate_callback : @storage + # sp.verify(self.data.state == 3, message = 12) # @parameter%liquidate_callback : @storage + PUSH int 3; # int : @parameter%liquidate_callback : @storage + DIG 2; # @storage : int : @parameter%liquidate_callback + DUP; # @storage : @storage : int : @parameter%liquidate_callback + DUG 3; # @storage : int : @parameter%liquidate_callback : @storage + CDDDAR; # int : int : @parameter%liquidate_callback : @storage + COMPARE; # int : @parameter%liquidate_callback : @storage + EQ; # bool : @parameter%liquidate_callback : @storage + IF + {} + { + PUSH int 12; # int : @parameter%liquidate_callback : @storage + FAILWITH; # FAILED + }; # @parameter%liquidate_callback : @storage + # sp.transfer((params, self.data.liquidateParams.open_some()), sp.balance, sp.contract(sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TAddress)))))))), self.data.minterContractAddress, entry_point='liquidate').open_some()) # @parameter%liquidate_callback : @storage + NIL operation; # list operation : @parameter%liquidate_callback : @storage + DIG 2; # @storage : list operation : @parameter%liquidate_callback + DUP; # @storage : @storage : list operation : @parameter%liquidate_callback + DUG 3; # @storage : list operation : @parameter%liquidate_callback : @storage + CADDAR; # address : list operation : @parameter%liquidate_callback : @storage + CONTRACT %liquidate (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))); # option (contract (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))))) : list operation : @parameter%liquidate_callback : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%liquidate_callback : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%liquidate_callback : @storage + BALANCE; # mutez : @some : list operation : @parameter%liquidate_callback : @storage + DIG 4; # @storage : mutez : @some : list operation : @parameter%liquidate_callback + DUP; # @storage : @storage : mutez : @some : list operation : @parameter%liquidate_callback + DUG 5; # @storage : mutez : @some : list operation : @parameter%liquidate_callback : @storage + CADAR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : mutez : @some : list operation : @parameter%liquidate_callback : @storage + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : @parameter%liquidate_callback : @storage + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : @parameter%liquidate_callback : @storage + DIG 4; # @parameter%liquidate_callback : @some : mutez : @some : list operation : @storage + PAIR; # pair @parameter%liquidate_callback @some : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + SWAP; # @storage : list operation + # self.data.state = 0 # @storage : list operation + DUP; # @storage : @storage : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PUSH int 0; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # self.data.liquidateParams = sp.none # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CAR; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + CDDR; # pair (address %minterContractAddress) (address %oracleContractAddress) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + NONE (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))); # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (address %minterContractAddress) (address %oracleContractAddress) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + SWAP; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + DROP; # @storage + # == pause == + # sp.verify(sp.sender == self.data.pauseGuardianContractAddress, message = 9) # @storage + DUP; # @storage : @storage + CDADR; # address : @storage + SENDER; # address : address : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 9; # int : @storage + FAILWITH; # FAILED + }; # @storage + # self.data.paused = True # @storage + DUP; # @storage : @storage + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CDDR; # pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PUSH bool True; # bool : pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + NIL operation; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + # == repay == + # sp.transfer(sp.sender, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%repay : @storage + NIL operation; # list operation : @parameter%repay : @storage + DIG 2; # @storage : list operation : @parameter%repay + DUP; # @storage : @storage : list operation : @parameter%repay + DUG 3; # @storage : list operation : @parameter%repay : @storage + CDAAR; # address : list operation : @parameter%repay : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%repay : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%repay : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%repay : @storage + SENDER; # address : mutez : @some : list operation : @parameter%repay : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%repay : @storage + CONS; # list operation : @parameter%repay : @storage + # sp.verify(self.data.paused == False, message = 18) # list operation : @parameter%repay : @storage + PUSH bool False; # bool : list operation : @parameter%repay : @storage + DIG 3; # @storage : bool : list operation : @parameter%repay + DUP; # @storage : @storage : bool : list operation : @parameter%repay + DUG 4; # @storage : bool : list operation : @parameter%repay : @storage + CDDAR; # bool : bool : list operation : @parameter%repay : @storage + COMPARE; # int : list operation : @parameter%repay : @storage + EQ; # bool : list operation : @parameter%repay : @storage + IF + {} + { + PUSH int 18; # int : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%repay : @storage + # sp.verify(self.data.state == 0, message = 12) # list operation : @parameter%repay : @storage + PUSH int 0; # int : list operation : @parameter%repay : @storage + DIG 3; # @storage : int : list operation : @parameter%repay + DUP; # @storage : @storage : int : list operation : @parameter%repay + DUG 4; # @storage : int : list operation : @parameter%repay : @storage + CDDDAR; # int : int : list operation : @parameter%repay : @storage + COMPARE; # int : list operation : @parameter%repay : @storage + EQ; # bool : list operation : @parameter%repay : @storage + IF + {} + { + PUSH int 12; # int : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%repay : @storage + # sp.transfer(params, sp.amount, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))), self.data.minterContractAddress, entry_point='repay').open_some()) # list operation : @parameter%repay : @storage + DIG 2; # @storage : list operation : @parameter%repay + DUP; # @storage : @storage : list operation : @parameter%repay + DUG 3; # @storage : list operation : @parameter%repay : @storage + CADDAR; # address : list operation : @parameter%repay : @storage + CONTRACT %repay (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) : list operation : @parameter%repay : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%repay : @storage + AMOUNT; # mutez : @some : list operation : @parameter%repay : @storage + DIG 3; # @parameter%repay : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CAADR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @storage : @parameter%setGovernorContract + SWAP; # @storage : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + CDR; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + CAAR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setGovernorContract + DIG 3; # @parameter%setGovernorContract : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) : @parameter%setGovernorContract : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + SWAP; # @storage : @parameter%setMinterContract + # == setMinterContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setMinterContract + DUP; # @storage : @storage : @parameter%setMinterContract + DUG 2; # @storage : @parameter%setMinterContract : @storage + CAADR; # address : @parameter%setMinterContract : @storage + SENDER; # address : address : @parameter%setMinterContract : @storage + COMPARE; # int : @parameter%setMinterContract : @storage + EQ; # bool : @parameter%setMinterContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setMinterContract : @storage + FAILWITH; # FAILED + }; # @parameter%setMinterContract : @storage + SWAP; # @storage : @parameter%setMinterContract + # self.data.minterContractAddress = params # @storage : @parameter%setMinterContract + DUP; # @storage : @storage : @parameter%setMinterContract + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @storage : @parameter%setMinterContract + SWAP; # @storage : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + CAR; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + CDR; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + DUP; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + CAR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + SWAP; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + CDDR; # address : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setMinterContract + DIG 4; # @parameter%setMinterContract : address : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair @parameter%setMinterContract address : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair @parameter%setMinterContract address : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair @parameter%setMinterContract address) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair @parameter%setMinterContract address) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair @parameter%setMinterContract address)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair @parameter%setMinterContract address))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setOracleContract + # == setOracleContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOracleContract + DUP; # @storage : @storage : @parameter%setOracleContract + DUG 2; # @storage : @parameter%setOracleContract : @storage + CAADR; # address : @parameter%setOracleContract : @storage + SENDER; # address : address : @parameter%setOracleContract : @storage + COMPARE; # int : @parameter%setOracleContract : @storage + EQ; # bool : @parameter%setOracleContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOracleContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOracleContract : @storage + SWAP; # @storage : @parameter%setOracleContract + # self.data.oracleContractAddress = params # @storage : @parameter%setOracleContract + DUP; # @storage : @storage : @parameter%setOracleContract + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @storage : @parameter%setOracleContract + SWAP; # @storage : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + DUP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + CAR; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + CDR; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + DUP; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + CAR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + SWAP; # pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)) : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + CDAR; # address : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : @parameter%setOracleContract + DIG 4; # @parameter%setOracleContract : address : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # address : @parameter%setOracleContract : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair address @parameter%setOracleContract : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))) : pair address @parameter%setOracleContract : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair address @parameter%setOracleContract) : pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + SWAP; # pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress) : pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair address @parameter%setOracleContract) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair address @parameter%setOracleContract)) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair address @parameter%setOracleContract))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + SWAP; # @storage : @parameter%setOvenRegistryContract + # == setOvenRegistryContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + DUG 2; # @storage : @parameter%setOvenRegistryContract : @storage + CAADR; # address : @parameter%setOvenRegistryContract : @storage + SENDER; # address : address : @parameter%setOvenRegistryContract : @storage + COMPARE; # int : @parameter%setOvenRegistryContract : @storage + EQ; # bool : @parameter%setOvenRegistryContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOvenRegistryContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOvenRegistryContract : @storage + SWAP; # @storage : @parameter%setOvenRegistryContract + # self.data.ovenRegistryContractAddress = params # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : @parameter%setOvenRegistryContract + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + CADR; # address : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setOvenRegistryContract + DIG 3; # @parameter%setOvenRegistryContract : address : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair @parameter%setOvenRegistryContract address : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair (pair @parameter%setOvenRegistryContract address) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair @parameter%setOvenRegistryContract address) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair @parameter%setOvenRegistryContract address) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair address @parameter%setOracleContract))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + NIL operation; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setPauseGuardianContract + # == setPauseGuardianContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setPauseGuardianContract + DUP; # @storage : @storage : @parameter%setPauseGuardianContract + DUG 2; # @storage : @parameter%setPauseGuardianContract : @storage + CAADR; # address : @parameter%setPauseGuardianContract : @storage + SENDER; # address : address : @parameter%setPauseGuardianContract : @storage + COMPARE; # int : @parameter%setPauseGuardianContract : @storage + EQ; # bool : @parameter%setPauseGuardianContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setPauseGuardianContract : @storage + FAILWITH; # FAILED + }; # @parameter%setPauseGuardianContract : @storage + SWAP; # @storage : @parameter%setPauseGuardianContract + # self.data.pauseGuardianContractAddress = params # @storage : @parameter%setPauseGuardianContract + DUP; # @storage : @storage : @parameter%setPauseGuardianContract + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : @parameter%setPauseGuardianContract + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + CAAR; # address : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @parameter%setPauseGuardianContract + DIG 3; # @parameter%setPauseGuardianContract : address : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # address : @parameter%setPauseGuardianContract : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair address @parameter%setPauseGuardianContract : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + DROP; # @storage + # == unpause == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage + DUP; # @storage : @storage + CAADR; # address : @storage + SENDER; # address : address : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 4; # int : @storage + FAILWITH; # FAILED + }; # @storage + # self.data.paused = False # @storage + DUP; # @storage : @storage + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + CDDR; # pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PUSH bool False; # bool : pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + NIL operation; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateState + # == updateState == + # sp.verify(sp.sender == self.data.minterContractAddress, message = 5) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + DUG 2; # @storage : @parameter%updateState : @storage + CADDAR; # address : @parameter%updateState : @storage + SENDER; # address : address : @parameter%updateState : @storage + COMPARE; # int : @parameter%updateState : @storage + EQ; # bool : @parameter%updateState : @storage + IF + {} + { + PUSH int 5; # int : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @parameter%updateState : @storage + # sp.transfer(params, sp.amount, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TBool)))), sp.fst(params), entry_point='updateState').open_some()) # @parameter%updateState : @storage + DUP; # @parameter%updateState : @parameter%updateState : @storage + CAR; # address : @parameter%updateState : @storage + CONTRACT %updateState (pair address (pair nat (pair int (pair int bool)))); # option (contract (pair address (pair nat (pair int (pair int bool))))) : @parameter%updateState : @storage + IF_SOME + {} + { + UNIT; # unit : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @some : @parameter%updateState : @storage + NIL operation; # list operation : @some : @parameter%updateState : @storage + SWAP; # @some : list operation : @parameter%updateState : @storage + AMOUNT; # mutez : @some : list operation : @parameter%updateState : @storage + DIG 3; # @parameter%updateState : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + IF_LEFT + { + # == withdraw == + # sp.transfer(sp.sender, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%withdraw : @storage + NIL operation; # list operation : @parameter%withdraw : @storage + DIG 2; # @storage : list operation : @parameter%withdraw + DUP; # @storage : @storage : list operation : @parameter%withdraw + DUG 3; # @storage : list operation : @parameter%withdraw : @storage + CDAAR; # address : list operation : @parameter%withdraw : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%withdraw : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%withdraw : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%withdraw : @storage + SENDER; # address : mutez : @some : list operation : @parameter%withdraw : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%withdraw : @storage + CONS; # list operation : @parameter%withdraw : @storage + # sp.verify(self.data.state == 0, message = 12) # list operation : @parameter%withdraw : @storage + PUSH int 0; # int : list operation : @parameter%withdraw : @storage + DIG 3; # @storage : int : list operation : @parameter%withdraw + DUP; # @storage : @storage : int : list operation : @parameter%withdraw + DUG 4; # @storage : int : list operation : @parameter%withdraw : @storage + CDDDAR; # int : int : list operation : @parameter%withdraw : @storage + COMPARE; # int : list operation : @parameter%withdraw : @storage + EQ; # bool : list operation : @parameter%withdraw : @storage + IF + {} + { + PUSH int 12; # int : list operation : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%withdraw : @storage + # sp.verify(self.data.paused == False, message = 18) # list operation : @parameter%withdraw : @storage + PUSH bool False; # bool : list operation : @parameter%withdraw : @storage + DIG 3; # @storage : bool : list operation : @parameter%withdraw + DUP; # @storage : @storage : bool : list operation : @parameter%withdraw + DUG 4; # @storage : bool : list operation : @parameter%withdraw : @storage + CDDAR; # bool : bool : list operation : @parameter%withdraw : @storage + COMPARE; # int : list operation : @parameter%withdraw : @storage + EQ; # bool : list operation : @parameter%withdraw : @storage + IF + {} + { + PUSH int 18; # int : list operation : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # list operation : @parameter%withdraw : @storage + # self.data.state = 2 # list operation : @parameter%withdraw : @storage + DIG 2; # @storage : list operation : @parameter%withdraw + DUP; # @storage : @storage : list operation : @parameter%withdraw + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation : @parameter%withdraw + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + PUSH int 2; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation : @parameter%withdraw + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%withdraw + # self.data.withdrawParams = sp.some(params) # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%withdraw + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%withdraw + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : @parameter%withdraw + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + DUP; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CAR; # bool : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + SWAP; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + CDAR; # int : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation : @parameter%withdraw + DIG 5; # @parameter%withdraw : int : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SOME; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : int : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # sp.transfer(sp.self_entry_point('withdraw_callback'), sp.tez(0), sp.contract(sp.TContract(sp.TNat), self.data.oracleContractAddress, entry_point='getXtzUsdRate').open_some()) # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUG 2; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CADDDR; # address : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONTRACT %getXtzUsdRate (contract nat); # option (contract (contract nat)) : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + IF_SOME + {} + { + UNIT; # unit : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + FAILWITH; # FAILED + }; # @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + PUSH mutez 0; # mutez : @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + SELF %withdraw_callback; # contract nat : mutez : @some : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + TRANSFER_TOKENS; # operation : list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + CONS; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + } + { + SWAP; # @storage : @parameter%withdraw_callback + # == withdraw_callback == + # sp.verify(sp.sender == self.data.oracleContractAddress, message = 3) # @storage : @parameter%withdraw_callback + DUP; # @storage : @storage : @parameter%withdraw_callback + DUG 2; # @storage : @parameter%withdraw_callback : @storage + CADDDR; # address : @parameter%withdraw_callback : @storage + SENDER; # address : address : @parameter%withdraw_callback : @storage + COMPARE; # int : @parameter%withdraw_callback : @storage + EQ; # bool : @parameter%withdraw_callback : @storage + IF + {} + { + PUSH int 3; # int : @parameter%withdraw_callback : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw_callback : @storage + # sp.verify(self.data.state == 2, message = 12) # @parameter%withdraw_callback : @storage + PUSH int 2; # int : @parameter%withdraw_callback : @storage + DIG 2; # @storage : int : @parameter%withdraw_callback + DUP; # @storage : @storage : int : @parameter%withdraw_callback + DUG 3; # @storage : int : @parameter%withdraw_callback : @storage + CDDDAR; # int : int : @parameter%withdraw_callback : @storage + COMPARE; # int : @parameter%withdraw_callback : @storage + EQ; # bool : @parameter%withdraw_callback : @storage + IF + {} + { + PUSH int 12; # int : @parameter%withdraw_callback : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw_callback : @storage + # sp.transfer((params, self.data.withdrawParams.open_some()), sp.balance, sp.contract(sp.TPair(sp.TNat, sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TMutez)))))))), self.data.minterContractAddress, entry_point='withdraw').open_some()) # @parameter%withdraw_callback : @storage + NIL operation; # list operation : @parameter%withdraw_callback : @storage + DIG 2; # @storage : list operation : @parameter%withdraw_callback + DUP; # @storage : @storage : list operation : @parameter%withdraw_callback + DUG 3; # @storage : list operation : @parameter%withdraw_callback : @storage + CADDAR; # address : list operation : @parameter%withdraw_callback : @storage + CONTRACT %withdraw (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))); # option (contract (pair nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : list operation : @parameter%withdraw_callback : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%withdraw_callback : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%withdraw_callback : @storage + BALANCE; # mutez : @some : list operation : @parameter%withdraw_callback : @storage + DIG 4; # @storage : mutez : @some : list operation : @parameter%withdraw_callback + DUP; # @storage : @storage : mutez : @some : list operation : @parameter%withdraw_callback + DUG 5; # @storage : mutez : @some : list operation : @parameter%withdraw_callback : @storage + CDDDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : mutez : @some : list operation : @parameter%withdraw_callback : @storage + IF_SOME + {} + { + UNIT; # unit : mutez : @some : list operation : @parameter%withdraw_callback : @storage + FAILWITH; # FAILED + }; # @some : mutez : @some : list operation : @parameter%withdraw_callback : @storage + DIG 4; # @parameter%withdraw_callback : @some : mutez : @some : list operation : @storage + PAIR; # pair @parameter%withdraw_callback @some : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + SWAP; # @storage : list operation + # self.data.state = 0 # @storage : list operation + DUP; # @storage : @storage : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : @storage : list operation + SWAP; # @storage : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # bool : pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDDR; # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PUSH int 0; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + # self.data.withdrawParams = sp.none # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + DUP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + CAR; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + DUP; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CAR; # bool : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + CDAR; # int : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + NONE (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))); # option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : int : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # int : option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : bool : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # bool : pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress) : pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + PAIR; # pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : list operation + SWAP; # pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress))) : pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))) : list operation + PAIR; # pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) : list operation + SWAP; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : @storage + }; # list operation : pair (pair (pair (option %borrowParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (address %governorContractAddress)) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair address @parameter%setPauseGuardianContract) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) @parameter%setGovernorContract) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair (bool %paused) (pair (int %state) (option %withdrawParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + NIL operation; # list operation : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + SWAP; # list operation : list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + ITER + { + CONS; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + }; # list operation : pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))) + PAIR; # pair (list operation) (pair (pair (pair (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) address) (pair (option %liquidateParams (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (pair (address %minterContractAddress) (address %oracleContractAddress)))) (pair (pair (address %ovenRegistryContractAddress) (address %pauseGuardianContractAddress)) (pair bool (pair int (option (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))))) + }; \ No newline at end of file diff --git a/smart_contracts/oven-registry.py b/smart_contracts/oven-registry.py new file mode 100644 index 00000000..dfa223d1 --- /dev/null +++ b/smart_contracts/oven-registry.py @@ -0,0 +1,319 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Errors = sp.import_script_from_url("file:common/errors.py") + +################################################################ +# Contract +################################################################ + +class OvenRegistryContract(sp.Contract): + def __init__( + self, + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + governorContractAddress = governorContractAddress, + ovenFactoryContractAddress = ovenFactoryContractAddress, + ovenMap = sp.big_map( + l = {}, + tkey=sp.TAddress, + tvalue=sp.TAddress + ) + ) + + ################################################################ + # Public Interface + ################################################################ + + @sp.entry_point + def isOven(self, maybeOvenAddress): + sp.verify(self.data.ovenMap.contains(maybeOvenAddress), message = Errors.NOT_OVEN) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Disallow direct transfers. + @sp.entry_point + def default(self, param): + sp.set_type(param, sp.TUnit) + sp.failwith(Errors.CANNOT_RECEIVE_FUNDS) + + ################################################################ + # OvenFactory Interface + ################################################################ + + # (oven address, owner) + @sp.entry_point + def addOven(self, param): + sp.set_type(param, sp.TPair(sp.TAddress, sp.TAddress)) + + sp.verify(sp.sender == self.data.ovenFactoryContractAddress, message = Errors.NOT_OVEN_FACTORY) + + ovenAddress = sp.fst(param) + owner = sp.snd(param) + + self.data.ovenMap[ovenAddress] = owner + + ################################################################ + # Governance + ################################################################ + + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # Update the oven factory contract address. + @sp.entry_point + def setOvenFactoryContract(self, newOvenFactoryContract): + sp.set_type(newOvenFactoryContract, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.ovenFactoryContractAddress = newOvenFactoryContract + + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + ################################################################ + # isOven + ################################################################ + + @sp.add_test(name="isOven - fails with unknown oven") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryContractAddress + ) + scenario += ovenRegistry + + # AND an oven that is registered in the OvenRegistry + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + addOvenParameter = (ovenAddress, ownerAddress) + scenario += ovenRegistry.addOven(addOvenParameter).run( + sender = ovenFactoryContractAddress + ) + + # WHEN isOven is called for an unregistered oven THEN the invocation fails. + notOven = Addresses.NULL_ADDRESS + scenario += ovenRegistry.isOven(notOven).run( + valid = False + ) + + @sp.add_test(name="isOven - succeeds with known oven") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryContractAddress + ) + scenario += ovenRegistry + + # AND an oven that is registered in the OvenRegistry + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + addOvenParameter = (ovenAddress, ownerAddress) + scenario += ovenRegistry.addOven(addOvenParameter).run( + sender = ovenFactoryContractAddress + ) + + # WHEN isOven is called for the oven THEN the invocation does not fail + scenario += ovenRegistry.isOven(ovenAddress) + + @sp.add_test(name="isOven - fails with known oven and an amount") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryContractAddress + ) + scenario += ovenRegistry + + # AND an oven that is registered in the OvenRegistry + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + addOvenParameter = (ovenAddress, ownerAddress) + scenario += ovenRegistry.addOven(addOvenParameter).run( + sender = ovenFactoryContractAddress + ) + + # WHEN isOven is called for the oven with an amount THEN the invocation does not fail + scenario += ovenRegistry.isOven(ovenAddress).run( + amount = sp.mutez(1), + valid = False + ) + + ################################################################ + # addOven + ################################################################ + + @sp.add_test(name="addOven - fails when not called by OvenFactory") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryContractAddress + ) + scenario += ovenRegistry + + # WHEN an oven is added to the contract by another contract THEN the invocation fails. + notOvenFactory = Addresses.NULL_ADDRESS + + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + addOvenParameter = (ovenAddress, ownerAddress) + + scenario += ovenRegistry.addOven(addOvenParameter).run( + sender = notOvenFactory, + valid = False + ) + + @sp.add_test(name="addOven - succeeds") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenFactoryContractAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryContractAddress + ) + scenario += ovenRegistry + + # WHEN an oven is added to the contract + ovenAddress = Addresses.OVEN_ADDRESS + ownerAddress = Addresses.OVEN_OWNER_ADDRESS + addOvenParameter = (ovenAddress, ownerAddress) + scenario += ovenRegistry.addOven(addOvenParameter).run( + sender = ovenFactoryContractAddress, + ) + + # THEN the OvenRegistry is registered in the registry's map. + scenario.verify(ovenRegistry.data.ovenMap[ovenAddress] == ownerAddress) + + # AND future calls to isOven report the oven as registered. + scenario += ovenRegistry.isOven(ovenAddress) + + ################################################################ + # default + ################################################################ + + @sp.add_test(name="default - fails with calls to the default entrypoint") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + ovenRegistry = OvenRegistryContract() + scenario += ovenRegistry + + # WHEN a transfer is made THEN the invocation fails. + scenario += ovenRegistry.default().run( + amount = sp.mutez(0), + valid = False + ) + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # WHEN the setGovernorContract is called with a new governor contract + newGovernorContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenRegistry.setGovernorContract(newGovernorContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the governor contract is updated. + scenario.verify(ovenRegistry.data.governorContractAddress == newGovernorContractAddress) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + newGovernorContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenRegistry.setGovernorContract(newGovernorContractAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setOvenFactoryContract + ################################################################ + + @sp.add_test(name="setOvenFactoryContract - succeeds when called by governor") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # WHEN the setOvenFactoryContract is called with a new governor contract + newOvenFactoryContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenRegistry.setOvenFactoryContract(newOvenFactoryContractAddress).run( + sender = governorContractAddress, + ) + + # THEN the governor contract is updated. + scenario.verify(ovenRegistry.data.ovenFactoryContractAddress == newOvenFactoryContractAddress) + + @sp.add_test(name="setOvenFactoryContract - fails when not called by governor") + def test(): + # GIVEN an OvenRegistry contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ovenRegistry = OvenRegistryContract( + governorContractAddress = governorContractAddress + ) + scenario += ovenRegistry + + # WHEN the setOvenFactoryContract is called by someone who isn't the governor THEN the call fails + newOvenFactoryContractAddress = Addresses.ROTATED_ADDRESS + scenario += ovenRegistry.setOvenFactoryContract(newOvenFactoryContractAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) diff --git a/smart_contracts/oven-registry.tz b/smart_contracts/oven-registry.tz new file mode 100644 index 00000000..264828ad --- /dev/null +++ b/smart_contracts/oven-registry.tz @@ -0,0 +1,140 @@ +parameter (or (or (pair %addOven address address) (unit %default)) (or (address %isOven) (or (address %setGovernorContract) (address %setOvenFactoryContract)))); +storage (pair (address %governorContractAddress) (pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%addOven + # == addOven == + # sp.verify(sp.sender == self.data.ovenFactoryContractAddress, message = 7) # @storage : @parameter%addOven + DUP; # @storage : @storage : @parameter%addOven + DUG 2; # @storage : @parameter%addOven : @storage + CDAR; # address : @parameter%addOven : @storage + SENDER; # address : address : @parameter%addOven : @storage + COMPARE; # int : @parameter%addOven : @storage + EQ; # bool : @parameter%addOven : @storage + IF + {} + { + PUSH int 7; # int : @parameter%addOven : @storage + FAILWITH; # FAILED + }; # @parameter%addOven : @storage + SWAP; # @storage : @parameter%addOven + # self.data.ovenMap[sp.fst(params)] = sp.snd(params) # @storage : @parameter%addOven + DUP; # @storage : @storage : @parameter%addOven + CAR; # address : @storage : @parameter%addOven + SWAP; # @storage : address : @parameter%addOven + CDR; # pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : address : @parameter%addOven + DUP; # pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : address : @parameter%addOven + CAR; # address : pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : address : @parameter%addOven + SWAP; # pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : address : address : @parameter%addOven + CDR; # big_map address address : address : address : @parameter%addOven + DIG 3; # @parameter%addOven : big_map address address : address : address + DUP; # @parameter%addOven : @parameter%addOven : big_map address address : address : address + CAR; # address : @parameter%addOven : big_map address address : address : address + SWAP; # @parameter%addOven : address : big_map address address : address : address + CDR; # address : address : big_map address address : address : address + SOME; # option address : address : big_map address address : address : address + SWAP; # address : option address : big_map address address : address : address + UPDATE; # big_map address address : address : address + SWAP; # address : big_map address address : address + PAIR; # pair address (big_map address address) : address + SWAP; # address : pair address (big_map address address) + PAIR; # pair address (pair address (big_map address address)) + } + { + PUSH int 19; # int : @parameter%default : @storage + FAILWITH; # FAILED + }; # pair address (pair address (big_map address address)) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%isOven + # == isOven == + # sp.verify(self.data.ovenMap.contains(params), message = 1) # @storage : @parameter%isOven + DUP; # @storage : @storage : @parameter%isOven + DUG 2; # @storage : @parameter%isOven : @storage + CDDR; # big_map address address : @parameter%isOven : @storage + SWAP; # @parameter%isOven : big_map address address : @storage + MEM; # bool : @storage + IF + {} + { + PUSH int 1; # int : @storage + FAILWITH; # FAILED + }; # @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @storage + PUSH mutez 0; # mutez : @storage + AMOUNT; # mutez : mutez : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 15; # int : @storage + FAILWITH; # FAILED + }; # @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CAR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + CDR; # pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) : @parameter%setGovernorContract + SWAP; # @parameter%setGovernorContract : pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address) + PAIR; # pair @parameter%setGovernorContract (pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address)) + } + { + SWAP; # @storage : @parameter%setOvenFactoryContract + # == setOvenFactoryContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOvenFactoryContract + DUP; # @storage : @storage : @parameter%setOvenFactoryContract + DUG 2; # @storage : @parameter%setOvenFactoryContract : @storage + CAR; # address : @parameter%setOvenFactoryContract : @storage + SENDER; # address : address : @parameter%setOvenFactoryContract : @storage + COMPARE; # int : @parameter%setOvenFactoryContract : @storage + EQ; # bool : @parameter%setOvenFactoryContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOvenFactoryContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOvenFactoryContract : @storage + SWAP; # @storage : @parameter%setOvenFactoryContract + # self.data.ovenFactoryContractAddress = params # @storage : @parameter%setOvenFactoryContract + DUP; # @storage : @storage : @parameter%setOvenFactoryContract + CAR; # address : @storage : @parameter%setOvenFactoryContract + SWAP; # @storage : address : @parameter%setOvenFactoryContract + CDDR; # big_map address address : address : @parameter%setOvenFactoryContract + DIG 2; # @parameter%setOvenFactoryContract : big_map address address : address + PAIR; # pair @parameter%setOvenFactoryContract (big_map address address) : address + SWAP; # address : pair @parameter%setOvenFactoryContract (big_map address address) + PAIR; # pair address (pair @parameter%setOvenFactoryContract (big_map address address)) + }; # pair @parameter%setGovernorContract (pair (address %ovenFactoryContractAddress) (big_map %ovenMap address address)) + }; # @storage + }; # pair address (pair address (big_map address address)) + NIL operation; # list operation : pair address (pair address (big_map address address)) + PAIR; # pair (list operation) (pair address (pair address (big_map address address))) + }; \ No newline at end of file diff --git a/smart_contracts/oven.py b/smart_contracts/oven.py new file mode 100644 index 00000000..5bd2606b --- /dev/null +++ b/smart_contracts/oven.py @@ -0,0 +1,666 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +Errors = sp.import_script_from_url("file:common/errors.py") +OvenApi = sp.import_script_from_url("file:common/oven-api.py") + +################################################################ +# Contract +################################################################ + +class OvenContract(sp.Contract): + # Initialize a new Oven. + # + # Parameters: + # owner: The owner of the oven. + def __init__( + self, + owner = Addresses.OVEN_OWNER_ADDRESS, + borrowedTokens = sp.nat(0), + stabilityFeeTokens = sp.int(0), + interestIndex = sp.to_int(Constants.PRECISION), + isLiquidated = False, + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContractAddress + ) + + ################################################################ + # Public API + ################################################################ + + @sp.entry_point + def borrow(self, tokensToBorrow): + sp.set_type(tokensToBorrow, sp.TNat) + + # Verify the caller is the owner. + sp.verify(sp.sender == self.data.owner, message = Errors.NOT_OWNER) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Convert mutez to 10^-18 scale. + normalizedBalance = sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call minter. + minterParam = (sp.to_address(sp.self), (self.data.owner, (normalizedBalance, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, tokensToBorrow))))))) + minterHandle = sp.contract( + OvenApi.BORROW_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.BORROW_ENTRY_POINT_NAME, + ).open_some() + sp.transfer(minterParam, sp.balance, minterHandle) + + @sp.entry_point + def repay(self, tokensToRepay): + sp.set_type(tokensToRepay, sp.TNat) + + # Verify the caller is the owner. + sp.verify(sp.sender == self.data.owner, message = Errors.NOT_OWNER) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Convert mutez to 10^-18 scale. + normalizedBalance = sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call minter. + minterParam = (sp.to_address(sp.self), (self.data.owner, (normalizedBalance, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, tokensToRepay))))))) + minterHandle = sp.contract( + OvenApi.REPAY_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.REPAY_ENTRY_POINT_NAME, + ).open_some() + sp.transfer(minterParam, sp.balance, minterHandle) + + @sp.entry_point + def withdraw(self, mutezToWithdraw): + sp.set_type(mutezToWithdraw, sp.TMutez) + + # Verify the caller is the owner. + sp.verify(sp.sender == self.data.owner, message = Errors.NOT_OWNER) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Convert mutez to 10^-18 scale. + normalizedBalance = sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call minter. + minterParam = (sp.to_address(sp.self), (self.data.owner, (normalizedBalance, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, mutezToWithdraw))))))) + minterHandle = sp.contract( + OvenApi.WITHDRAW_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.WITHDRAW_ENTRY_POINT_NAME, + ).open_some() + sp.transfer(minterParam, sp.balance, minterHandle) + + # Note this entrypoint is the 'default' point, but semantically it represents the 'deposit' function. + @sp.entry_point + def default(self, unit): + sp.set_type(unit, sp.TUnit) + + # Convert mutez to 10^-18 scale. + normalizedBalance = sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call minter. Send along the new deposit, and the old deposits. + minterAmount = sp.balance + minterParam = (sp.to_address(sp.self), (self.data.owner, (normalizedBalance, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, self.data.interestIndex)))))) + minterHandle = sp.contract( + OvenApi.DEPOSIT_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.DEPOSIT_ENTRY_POINT_NAME, + ).open_some() + sp.transfer(minterParam, minterAmount, minterHandle) + + @sp.entry_point + def liquidate(self, unit): + sp.set_type(unit, sp.TUnit) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + # Convert mutez to 10^-18 scale. + normalizedBalance = sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + + # Call minter. + minterParam = (sp.to_address(sp.self), (self.data.owner, (normalizedBalance, (self.data.borrowedTokens, ((self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, sp.sender)))))))) + minterHandle = sp.contract( + OvenApi.LIQUIDATE_PARAMETER_TYPE, + self.data.ovenProxyContractAddress, + OvenApi.LIQUIDATE_ENTRY_POINT_NAME, + ).open_some() + sp.transfer(minterParam, sp.balance, minterHandle) + + @sp.entry_point + def setDelegate(self, newDelegate): + sp.set_type(newDelegate, sp.TOption(sp.TKeyHash)) + + # Verify the caller is the owner. + sp.verify(sp.sender == self.data.owner, message = Errors.NOT_OWNER) + + # Verify the call did not contain a balance. + sp.verify(sp.amount == sp.mutez(0), message = Errors.AMOUNT_NOT_ALLOWED) + + sp.set_delegate(newDelegate) + + ################################################################ + # Minter Interface + ################################################################ + + @sp.entry_point + def updateState(self, param): + sp.set_type(param, OvenApi.UPDATE_STATE_PARAMETER_TYPE) + + # Verify input came from Minter and was addressed correctly. + sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = Errors.NOT_OVEN_PROXY) + sp.verify(sp.fst(param) == sp.to_address(sp.self), message = Errors.BAD_DESTINATION) + + self.data.borrowedTokens = sp.fst(sp.snd(param)) + self.data.stabilityFeeTokens = sp.fst(sp.snd(sp.snd(param))) + self.data.interestIndex = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.isLiquidated = sp.snd(sp.snd(sp.snd(sp.snd(param)))) + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + MockOvenProxy = sp.import_script_from_url("file:test-helpers/mock-oven-proxy.py") + + ################################################################ + # Borrow + ################################################################ + + @sp.add_test(name="borrow - fails with bad owner") + def test(): + # GIVEN a oven contract with an owner. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN borrow is called by someone other than the owner THEN the invocation fails. + notOwner = Addresses.NULL_ADDRESS + scenario += contract.borrow(1).run( + sender = notOwner, + valid = False + ) + + @sp.add_test(name="borrow - fails with amount") + def test(): + # GIVEN a oven contract. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN borrow is called with an amount of mutez THEN the invocation fails. + scenario += contract.borrow(1).run( + sender = owner, + amount = sp.mutez(1), + valid = False + ) + + @sp.add_test(name="borrow - calls oven proxy successfully") + def test(): + # GIVEN a oven contract, a mock oven proxy, and some parameters set in the oven. + scenario = sp.test_scenario() + + borrowedTokens = 1 + stabilityFeeTokens = 2 + interestIndex = 3 + isLiquidated = True + owner = Addresses.OVEN_OWNER_ADDRESS + contractBalance = sp.mutez(4) + + ovenProxyContract = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxyContract + + contract = OvenContract( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContract.address + ) + contract.set_initial_balance(contractBalance) + scenario += contract + + # WHEN borrow is called + tokensToBorrow = sp.nat(5) + scenario += contract.borrow(tokensToBorrow).run( + sender = owner, + ) + + # THEN the parameters were passed to the minter correctly. + expectedBalance = sp.fst(sp.ediv(contractBalance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(ovenProxyContract.data.borrow_ovenAddress == contract.address) + scenario.verify(ovenProxyContract.data.borrow_ownerAddress == owner) + scenario.verify(ovenProxyContract.data.borrow_ovenBalance == expectedBalance) + scenario.verify(ovenProxyContract.data.borrow_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxyContract.data.borrow_liquidated == isLiquidated) + scenario.verify(ovenProxyContract.data.borrow_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(ovenProxyContract.data.borrow_ovenInterestIndex == interestIndex) + scenario.verify(ovenProxyContract.data.borrow_tokensToBorrow == tokensToBorrow) + + # AND the minter has the balance of the oven. + scenario.verify(ovenProxyContract.balance == contractBalance) + + ################################################################ + # Repay + ################################################################ + + @sp.add_test(name="repay - fails with bad owner") + def test(): + # GIVEN a oven contract with an owner. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN repay is called by someone other than the owner THEN the invocation fails. + notOwner = Addresses.NULL_ADDRESS + scenario += contract.repay(1).run( + sender = notOwner, + valid = False + ) + + @sp.add_test(name="repay - fails with amount") + def test(): + # GIVEN a oven contract. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN repay is called with an amount THEN the invocation fails. + scenario += contract.repay(1).run( + sender = owner, + amount = sp.mutez(1), + valid = False + ) + + @sp.add_test(name="repay - calls oven proxy successfully") + def test(): + # GIVEN a oven contract, a mock oven proxy, and some parameters set in the oven. + scenario = sp.test_scenario() + + borrowedTokens = 1 + stabilityFeeTokens = 2 + interestIndex = 3 + isLiquidated = True + owner = Addresses.OVEN_OWNER_ADDRESS + contractBalance = sp.mutez(4) + + ovenProxyContract = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxyContract + + contract = OvenContract( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContract.address + ) + contract.set_initial_balance(contractBalance) + scenario += contract + + # WHEN repay is called + tokensToRepay = sp.nat(5) + scenario += contract.repay(tokensToRepay).run( + sender = owner, + ) + + # THEN the parameters were passed to the minter correctly. + expectedBalance = sp.fst(sp.ediv(contractBalance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(ovenProxyContract.data.repay_ovenAddress == contract.address) + scenario.verify(ovenProxyContract.data.repay_ownerAddress == owner) + scenario.verify(ovenProxyContract.data.repay_ovenBalance == expectedBalance) + scenario.verify(ovenProxyContract.data.repay_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxyContract.data.repay_liquidated == isLiquidated) + scenario.verify(ovenProxyContract.data.repay_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(ovenProxyContract.data.repay_ovenInterestIndex == interestIndex) + scenario.verify(ovenProxyContract.data.repay_tokensToRepay == tokensToRepay) + + # AND the minter has the balance of the oven. + scenario.verify(ovenProxyContract.balance == contractBalance) + + ################################################################ + # Default (Deposit) + ################################################################ + + @sp.add_test(name="default - calls oven proxy successfully") + def test(): + # GIVEN a oven contract, a mock oven proxy, and some parameters set in the oven. + scenario = sp.test_scenario() + + borrowedTokens = 1 + stabilityFeeTokens = 2 + interestIndex = 3 + isLiquidated = True + owner = Addresses.OVEN_OWNER_ADDRESS + contractBalance = sp.mutez(4) + + ovenProxyContract = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxyContract + + contract = OvenContract( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContract.address + ) + contract.set_initial_balance(contractBalance) + scenario += contract + + # WHEN the default (deposit) entrypoint is called + amountToDeposit = sp.mutez(5) + scenario += contract.default(sp.unit).run( + sender = owner, + amount = amountToDeposit + ) + + # THEN the parameters were passed to the minter correctly. + expectedBalance = sp.fst(sp.ediv((contractBalance + amountToDeposit), sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(ovenProxyContract.data.deposit_ovenAddress == contract.address) + scenario.verify(ovenProxyContract.data.deposit_ownerAddress == owner) + scenario.verify(ovenProxyContract.data.deposit_ovenBalance == expectedBalance) + scenario.verify(ovenProxyContract.data.deposit_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxyContract.data.deposit_liquidated == isLiquidated) + scenario.verify(ovenProxyContract.data.deposit_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(ovenProxyContract.data.deposit_ovenInterestIndex == interestIndex) + + # AND the minter has the balance of the oven. + scenario.verify(ovenProxyContract.balance == (contractBalance + amountToDeposit)) + + ################################################################ + # Withdraw + ################################################################ + + @sp.add_test(name="withdraw - fails with bad owner") + def test(): + # GIVEN a oven contract with an owner. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN withdraw is called by someone other than the owner THEN the invocation fails. + notOwner = Addresses.NULL_ADDRESS + scenario += contract.withdraw(sp.mutez(1)).run( + sender = notOwner, + valid = False + ) + + @sp.add_test(name="withdraw - fails with an amount") + def test(): + # GIVEN a oven contract. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN withdraw is called with an amount THEN the invocation fails. + scenario += contract.withdraw(sp.mutez(1)).run( + sender = owner, + amount = sp.mutez(1), + valid = False + ) + + + @sp.add_test(name="withdraw - calls oven proxy successfully") + def test(): + # GIVEN a oven contract, a mock oven proxy, and some parameters set in the oven. + scenario = sp.test_scenario() + + borrowedTokens = 1 + stabilityFeeTokens = 2 + interestIndex = 3 + isLiquidated = True + owner = Addresses.OVEN_OWNER_ADDRESS + contractBalance = sp.mutez(4) + + ovenProxyContract = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxyContract + + contract = OvenContract( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContract.address + ) + contract.set_initial_balance(contractBalance) + scenario += contract + + # WHEN withdraw is called + mutezToWithdraw = sp.mutez(5) + scenario += contract.withdraw(mutezToWithdraw).run( + sender = owner, + ) + + # THEN the parameters were passed to the minter correctly. + expectedBalance = sp.fst(sp.ediv(contractBalance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(ovenProxyContract.data.withdraw_ovenAddress == contract.address) + scenario.verify(ovenProxyContract.data.withdraw_ownerAddress == owner) + scenario.verify(ovenProxyContract.data.withdraw_ovenBalance == expectedBalance) + scenario.verify(ovenProxyContract.data.withdraw_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxyContract.data.withdraw_liquidated == isLiquidated) + scenario.verify(ovenProxyContract.data.withdraw_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(ovenProxyContract.data.withdraw_ovenInterestIndex == interestIndex) + scenario.verify(ovenProxyContract.data.withdraw_mutezToWithdraw == mutezToWithdraw) + + # AND the minter has the balance of the oven. + scenario.verify(ovenProxyContract.balance == contractBalance) + + ################################################################ + # Liquidate + ################################################################ + + @sp.add_test(name="liquidate - fails with an amount") + def test(): + # GIVEN a oven contract. + scenario = sp.test_scenario() + + contract = OvenContract() + scenario += contract + + # WHEN liquidate is called with an amount THEN the invocation fails. + scenario += contract.withdraw(sp.mutez(1)).run( + amount = sp.mutez(1), + valid = False + ) + + @sp.add_test(name="liquidate - calls oven proxy successfully") + def test(): + # GIVEN a oven contract, a mock oven proxy, and some parameters set in the oven. + scenario = sp.test_scenario() + + borrowedTokens = 1 + stabilityFeeTokens = 2 + interestIndex = 3 + isLiquidated = True + owner = Addresses.OVEN_OWNER_ADDRESS + contractBalance = sp.mutez(4) + + ovenProxyContract = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxyContract + + contract = OvenContract( + owner = owner, + borrowedTokens = borrowedTokens, + stabilityFeeTokens = stabilityFeeTokens, + interestIndex = interestIndex, + isLiquidated = isLiquidated, + ovenProxyContractAddress = ovenProxyContract.address + ) + contract.set_initial_balance(contractBalance) + scenario += contract + + # WHEN liquidate is called + liquidatorAddress = Addresses.LIQUIDATOR_ADDRESS + scenario += contract.liquidate(sp.unit).run( + sender = liquidatorAddress, + ) + + # THEN the parameters were passed to the minter correctly. + expectedBalance = sp.fst(sp.ediv(contractBalance, sp.mutez(1)).open_some()) * Constants.MUTEZ_TO_KOLIBRI_CONVERSION + scenario.verify(ovenProxyContract.data.liquidate_ovenAddress == contract.address) + scenario.verify(ovenProxyContract.data.liquidate_ownerAddress == owner) + scenario.verify(ovenProxyContract.data.liquidate_ovenBalance == expectedBalance) + scenario.verify(ovenProxyContract.data.liquidate_borrowedTokens == borrowedTokens) + scenario.verify(ovenProxyContract.data.liquidate_liquidated == isLiquidated) + scenario.verify(ovenProxyContract.data.liquidate_stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(ovenProxyContract.data.liquidate_ovenInterestIndex == interestIndex) + scenario.verify(ovenProxyContract.data.liquidate_liquidatorAddress == liquidatorAddress) + + # AND the minter has the balance of the oven. + scenario.verify(ovenProxyContract.balance == contractBalance) + + ################################################################ + # Set Delegate + ################################################################ + + @sp.add_test(name="setDelegate - fails with bad owner") + def test(): + # GIVEN a oven contract without a delegate and an owner. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN setDelegate is called by someone other than the owner THEN the invocation fails. + notOwner = Addresses.NULL_ADDRESS + delegate = sp.some(sp.key_hash("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf")) + scenario += contract.setDelegate(delegate).run( + sender = notOwner, + valid = False + ) + + @sp.add_test(name="setDelegate - updates delegate") + def test(): + # GIVEN a oven contract without a delegate and an owner. + scenario = sp.test_scenario() + owner = Addresses.OVEN_OWNER_ADDRESS + + contract = OvenContract( + owner = owner + ) + scenario += contract + + # WHEN setDelegate is called by the owner + delegate = sp.some(sp.key_hash("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf")) + scenario += contract.setDelegate(delegate).run( + sender = owner, + ) + + # THEN the delegate is updated. + scenario.verify(contract.baker.open_some() == delegate.open_some()) + + ################################################################ + # Update State + ################################################################ + + @sp.add_test(name="updateState - fails when sender is not OvenProxy") + def test(): + # GIVEN a oven contract with an oven contract proxy. + scenario = sp.test_scenario() + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS + + contract = OvenContract( + ovenProxyContractAddress = ovenProxyContractAddress + ) + scenario += contract + + # WHEN updateState is called by someone other than the OvenProxy THEN the invocation fails. + notOvenProxy = Addresses.NULL_ADDRESS + update = (contract.address, (12, (13, (14, False)))) + scenario += contract.updateState(update).run( + sender = notOvenProxy, + valid = False + ) + + @sp.add_test(name="updateState - fails when addressee is not oven") + def test(): + # GIVEN a oven contract with an oven contract proxy. + scenario = sp.test_scenario() + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS + + contract = OvenContract( + ovenProxyContractAddress = ovenProxyContractAddress + ) + scenario += contract + + # WHEN updateState is called with an address that is not the Oven THEN the invocation fails. + update = (ovenProxyContractAddress, (12, (13, (14, False)))) + scenario += contract.updateState(update).run( + sender = ovenProxyContractAddress, + valid = False + ) + + @sp.add_test(name="updateState - successfully updates state") + def test(): + # GIVEN a oven contract with an oven contract proxy. + scenario = sp.test_scenario() + ovenProxyContractAddress = Addresses.OVEN_PROXY_ADDRESS + + contract = OvenContract( + ovenProxyContractAddress = ovenProxyContractAddress + ) + scenario += contract + + # WHEN updateState is called by the OvenProxy + borrowedTokens = sp.nat(12) + stabilityFeeTokens = sp.int(13) + interestIndex = sp.int(14) + isLiquidated = sp.bool(True) + update = (contract.address, (borrowedTokens, (stabilityFeeTokens, (interestIndex, isLiquidated)))) + scenario += contract.updateState(update).run( + sender = ovenProxyContractAddress, + ) + + # THEN the values are updated. + scenario.verify(contract.data.borrowedTokens == borrowedTokens) + scenario.verify(contract.data.stabilityFeeTokens == stabilityFeeTokens) + scenario.verify(contract.data.interestIndex == interestIndex) + scenario.verify(contract.data.isLiquidated == isLiquidated) diff --git a/smart_contracts/oven.tz b/smart_contracts/oven.tz new file mode 100644 index 00000000..afd8e0c7 --- /dev/null +++ b/smart_contracts/oven.tz @@ -0,0 +1,544 @@ +parameter (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))); +storage (pair (pair (nat %borrowedTokens) (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%borrow + # == borrow == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%borrow + DUP; # @storage : @storage : @parameter%borrow + DUG 2; # @storage : @parameter%borrow : @storage + CDDAR; # address : @parameter%borrow : @storage + SENDER; # address : address : @parameter%borrow : @storage + COMPARE; # int : @parameter%borrow : @storage + EQ; # bool : @parameter%borrow : @storage + IF + {} + { + PUSH int 6; # int : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @parameter%borrow : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%borrow : @storage + PUSH mutez 0; # mutez : @parameter%borrow : @storage + AMOUNT; # mutez : mutez : @parameter%borrow : @storage + COMPARE; # int : @parameter%borrow : @storage + EQ; # bool : @parameter%borrow : @storage + IF + {} + { + PUSH int 15; # int : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @parameter%borrow : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))), self.data.ovenProxyContractAddress, entry_point='borrow').open_some()) # @parameter%borrow : @storage + NIL operation; # list operation : @parameter%borrow : @storage + DIG 2; # @storage : list operation : @parameter%borrow + DUP; # @storage : @storage : list operation : @parameter%borrow + DUG 3; # @storage : list operation : @parameter%borrow : @storage + CDAR; # address : list operation : @parameter%borrow : @storage + CONTRACT %borrow (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) : list operation : @parameter%borrow : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%borrow : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%borrow : @storage + BALANCE; # mutez : @some : list operation : @parameter%borrow : @storage + DIG 3; # @parameter%borrow : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%borrow : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%borrow : mutez : @some : list operation + DUG 5; # @storage : @parameter%borrow : mutez : @some : list operation : @storage + CADAR; # int : @parameter%borrow : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%borrow : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%borrow : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%borrow : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%borrow : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%borrow : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%borrow) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%borrow)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%borrow))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%borrow)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + IF_LEFT + { + DROP; # @storage + # == default == + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, self.data.interestIndex)))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TInt)))))), self.data.ovenProxyContractAddress, entry_point='deposit').open_some()) # @storage + DUP; # @storage : @storage + CDAR; # address : @storage + CONTRACT %deposit (pair address (pair address (pair nat (pair nat (pair bool (pair int int)))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int int))))))) : @storage + IF_SOME + {} + { + UNIT; # unit : @storage + FAILWITH; # FAILED + }; # @some : @storage + NIL operation; # list operation : @some : @storage + SWAP; # @some : list operation : @storage + BALANCE; # mutez : @some : list operation : @storage + DIG 3; # @storage : mutez : @some : list operation + DUP; # @storage : @storage : mutez : @some : list operation + CADAR; # int : @storage : mutez : @some : list operation + SWAP; # @storage : int : mutez : @some : list operation + DUP; # @storage : @storage : int : mutez : @some : list operation + DUG 5; # @storage : int : mutez : @some : list operation : @storage + CDDDR; # int : int : mutez : @some : list operation : @storage + PAIR; # pair int int : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int int : mutez : @some : list operation + DUP; # @storage : @storage : pair int int : mutez : @some : list operation + DUG 5; # @storage : pair int int : mutez : @some : list operation : @storage + CADDR; # bool : pair int int : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int int) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int int) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int int) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int int) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int int) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int int)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int int))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int int)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int int))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + DROP; # @storage + # == liquidate == + # sp.verify(sp.amount == sp.tez(0), message = 15) # @storage + PUSH mutez 0; # mutez : @storage + AMOUNT; # mutez : mutez : @storage + COMPARE; # int : @storage + EQ; # bool : @storage + IF + {} + { + PUSH int 15; # int : @storage + FAILWITH; # FAILED + }; # @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, sp.sender))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TAddress))))))), self.data.ovenProxyContractAddress, entry_point='liquidate').open_some()) # @storage + DUP; # @storage : @storage + CDAR; # address : @storage + CONTRACT %liquidate (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) : @storage + IF_SOME + {} + { + UNIT; # unit : @storage + FAILWITH; # FAILED + }; # @some : @storage + NIL operation; # list operation : @some : @storage + SWAP; # @some : list operation : @storage + BALANCE; # mutez : @some : list operation : @storage + SENDER; # address : mutez : @some : list operation : @storage + DIG 4; # @storage : address : mutez : @some : list operation + DUP; # @storage : @storage : address : mutez : @some : list operation + DUG 5; # @storage : address : mutez : @some : list operation : @storage + CADAR; # int : address : mutez : @some : list operation : @storage + PAIR; # pair int address : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int address : mutez : @some : list operation + DUP; # @storage : @storage : pair int address : mutez : @some : list operation + DUG 5; # @storage : pair int address : mutez : @some : list operation : @storage + CDDDR; # int : pair int address : mutez : @some : list operation : @storage + PAIR; # pair int (pair int address) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int address) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int address) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int address) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int address) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int address)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int address))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int address)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int address))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%repay + # == repay == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%repay + DUP; # @storage : @storage : @parameter%repay + DUG 2; # @storage : @parameter%repay : @storage + CDDAR; # address : @parameter%repay : @storage + SENDER; # address : address : @parameter%repay : @storage + COMPARE; # int : @parameter%repay : @storage + EQ; # bool : @parameter%repay : @storage + IF + {} + { + PUSH int 6; # int : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @parameter%repay : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%repay : @storage + PUSH mutez 0; # mutez : @parameter%repay : @storage + AMOUNT; # mutez : mutez : @parameter%repay : @storage + COMPARE; # int : @parameter%repay : @storage + EQ; # bool : @parameter%repay : @storage + IF + {} + { + PUSH int 15; # int : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @parameter%repay : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TNat))))))), self.data.ovenProxyContractAddress, entry_point='repay').open_some()) # @parameter%repay : @storage + NIL operation; # list operation : @parameter%repay : @storage + DIG 2; # @storage : list operation : @parameter%repay + DUP; # @storage : @storage : list operation : @parameter%repay + DUG 3; # @storage : list operation : @parameter%repay : @storage + CDAR; # address : list operation : @parameter%repay : @storage + CONTRACT %repay (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) : list operation : @parameter%repay : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%repay : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%repay : @storage + BALANCE; # mutez : @some : list operation : @parameter%repay : @storage + DIG 3; # @parameter%repay : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%repay : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%repay : mutez : @some : list operation + DUG 5; # @storage : @parameter%repay : mutez : @some : list operation : @storage + CADAR; # int : @parameter%repay : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%repay : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%repay : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%repay : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%repay : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%repay : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%repay) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%repay)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%repay))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%repay)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%setDelegate + # == setDelegate == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%setDelegate + DUP; # @storage : @storage : @parameter%setDelegate + DUG 2; # @storage : @parameter%setDelegate : @storage + CDDAR; # address : @parameter%setDelegate : @storage + SENDER; # address : address : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 6; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%setDelegate : @storage + PUSH mutez 0; # mutez : @parameter%setDelegate : @storage + AMOUNT; # mutez : mutez : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 15; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.set_delegate(params) # @parameter%setDelegate : @storage + SET_DELEGATE; # operation : @storage + NIL operation; # list operation : operation : @storage + SWAP; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateState + # == updateState == + # sp.verify(sp.sender == self.data.ovenProxyContractAddress, message = 2) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + DUG 2; # @storage : @parameter%updateState : @storage + CDAR; # address : @parameter%updateState : @storage + SENDER; # address : address : @parameter%updateState : @storage + COMPARE; # int : @parameter%updateState : @storage + EQ; # bool : @parameter%updateState : @storage + IF + {} + { + PUSH int 2; # int : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @parameter%updateState : @storage + # sp.verify(sp.fst(params) == sp.self_address, message = 13) # @parameter%updateState : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : @parameter%updateState : @storage + ADDRESS; # address : @parameter%updateState : @storage + SWAP; # @parameter%updateState : address : @storage + DUP; # @parameter%updateState : @parameter%updateState : address : @storage + DUG 2; # @parameter%updateState : address : @parameter%updateState : @storage + CAR; # address : address : @parameter%updateState : @storage + COMPARE; # int : @parameter%updateState : @storage + EQ; # bool : @parameter%updateState : @storage + IF + {} + { + PUSH int 13; # int : @parameter%updateState : @storage + FAILWITH; # FAILED + }; # @parameter%updateState : @storage + SWAP; # @storage : @parameter%updateState + # self.data.borrowedTokens = sp.fst(sp.snd(params)) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + CDR; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @storage : @parameter%updateState + SWAP; # @storage : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + CADR; # pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + DIG 2; # @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) + DUP; # @parameter%updateState : @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) + DUG 3; # @parameter%updateState : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + CDAR; # nat : pair (int %interestIndex) (bool %isLiquidated) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + PAIR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : @parameter%updateState + PAIR; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + # self.data.stabilityFeeTokens = sp.fst(sp.snd(sp.snd(params))) # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + DUP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + CAR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : @parameter%updateState + SWAP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens))) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDR; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + DUP; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CAR; # address : pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # pair (address %ovenProxyContractAddress) (pair (address %owner) (int %stabilityFeeTokens)) : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDAR; # address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + DIG 3; # @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) + DUP; # @parameter%updateState : @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) + DUG 4; # @parameter%updateState : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + CDDAR; # int : address : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # address : int : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + PAIR; # pair address int : address : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # address : pair address int : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + PAIR; # pair address (pair address int) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : @parameter%updateState + SWAP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + PAIR; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + # self.data.interestIndex = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + DUP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + CDR; # pair address (pair address int) : pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : @parameter%updateState + SWAP; # pair (pair nat (pair (int %interestIndex) (bool %isLiquidated))) (pair address (pair address int)) : pair address (pair address int) : @parameter%updateState + CAR; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + DUP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + CAR; # nat : pair nat (pair (int %interestIndex) (bool %isLiquidated)) : pair address (pair address int) : @parameter%updateState + SWAP; # pair nat (pair (int %interestIndex) (bool %isLiquidated)) : nat : pair address (pair address int) : @parameter%updateState + CDDR; # bool : nat : pair address (pair address int) : @parameter%updateState + DIG 3; # @parameter%updateState : bool : nat : pair address (pair address int) + DUP; # @parameter%updateState : @parameter%updateState : bool : nat : pair address (pair address int) + DUG 4; # @parameter%updateState : bool : nat : pair address (pair address int) : @parameter%updateState + CDDDAR; # int : bool : nat : pair address (pair address int) : @parameter%updateState + PAIR; # pair int bool : nat : pair address (pair address int) : @parameter%updateState + SWAP; # nat : pair int bool : pair address (pair address int) : @parameter%updateState + PAIR; # pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + PAIR; # pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + # self.data.isLiquidated = sp.snd(sp.snd(sp.snd(sp.snd(params)))) # pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + DUP; # pair (pair nat (pair int bool)) (pair address (pair address int)) : pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + CDR; # pair address (pair address int) : pair (pair nat (pair int bool)) (pair address (pair address int)) : @parameter%updateState + SWAP; # pair (pair nat (pair int bool)) (pair address (pair address int)) : pair address (pair address int) : @parameter%updateState + CAR; # pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + DUP; # pair nat (pair int bool) : pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + CAR; # nat : pair nat (pair int bool) : pair address (pair address int) : @parameter%updateState + SWAP; # pair nat (pair int bool) : nat : pair address (pair address int) : @parameter%updateState + CDAR; # int : nat : pair address (pair address int) : @parameter%updateState + DIG 3; # @parameter%updateState : int : nat : pair address (pair address int) + CDDDDR; # bool : int : nat : pair address (pair address int) + SWAP; # int : bool : nat : pair address (pair address int) + PAIR; # pair int bool : nat : pair address (pair address int) + SWAP; # nat : pair int bool : pair address (pair address int) + PAIR; # pair nat (pair int bool) : pair address (pair address int) + PAIR; # pair (pair nat (pair int bool)) (pair address (pair address int)) + NIL operation; # list operation : pair (pair nat (pair int bool)) (pair address (pair address int)) + } + { + SWAP; # @storage : @parameter%withdraw + # == withdraw == + # sp.verify(sp.sender == self.data.owner, message = 6) # @storage : @parameter%withdraw + DUP; # @storage : @storage : @parameter%withdraw + DUG 2; # @storage : @parameter%withdraw : @storage + CDDAR; # address : @parameter%withdraw : @storage + SENDER; # address : address : @parameter%withdraw : @storage + COMPARE; # int : @parameter%withdraw : @storage + EQ; # bool : @parameter%withdraw : @storage + IF + {} + { + PUSH int 6; # int : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw : @storage + # sp.verify(sp.amount == sp.tez(0), message = 15) # @parameter%withdraw : @storage + PUSH mutez 0; # mutez : @parameter%withdraw : @storage + AMOUNT; # mutez : mutez : @parameter%withdraw : @storage + COMPARE; # int : @parameter%withdraw : @storage + EQ; # bool : @parameter%withdraw : @storage + IF + {} + { + PUSH int 15; # int : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @parameter%withdraw : @storage + # sp.transfer((sp.self_address, (self.data.owner, (sp.fst(sp.ediv(sp.balance, sp.mutez(1)).open_some()) * 1000000000000, (self.data.borrowedTokens, (self.data.isLiquidated, (self.data.stabilityFeeTokens, (self.data.interestIndex, params))))))), sp.balance, sp.contract(sp.TPair(sp.TAddress, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TPair(sp.TNat, sp.TPair(sp.TBool, sp.TPair(sp.TInt, sp.TPair(sp.TInt, sp.TMutez))))))), self.data.ovenProxyContractAddress, entry_point='withdraw').open_some()) # @parameter%withdraw : @storage + NIL operation; # list operation : @parameter%withdraw : @storage + DIG 2; # @storage : list operation : @parameter%withdraw + DUP; # @storage : @storage : list operation : @parameter%withdraw + DUG 3; # @storage : list operation : @parameter%withdraw : @storage + CDAR; # address : list operation : @parameter%withdraw : @storage + CONTRACT %withdraw (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))); # option (contract (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))) : list operation : @parameter%withdraw : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%withdraw : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%withdraw : @storage + BALANCE; # mutez : @some : list operation : @parameter%withdraw : @storage + DIG 3; # @parameter%withdraw : mutez : @some : list operation : @storage + DIG 4; # @storage : @parameter%withdraw : mutez : @some : list operation + DUP; # @storage : @storage : @parameter%withdraw : mutez : @some : list operation + DUG 5; # @storage : @parameter%withdraw : mutez : @some : list operation : @storage + CADAR; # int : @parameter%withdraw : mutez : @some : list operation : @storage + PAIR; # pair int @parameter%withdraw : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int @parameter%withdraw : mutez : @some : list operation + DUP; # @storage : @storage : pair int @parameter%withdraw : mutez : @some : list operation + DUG 5; # @storage : pair int @parameter%withdraw : mutez : @some : list operation : @storage + CDDDR; # int : pair int @parameter%withdraw : mutez : @some : list operation : @storage + PAIR; # pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation + DUP; # @storage : @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation + DUG 5; # @storage : pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + CADDR; # bool : pair int (pair int @parameter%withdraw) : mutez : @some : list operation : @storage + PAIR; # pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation + DUP; # @storage : @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation + DUG 5; # @storage : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + CAAR; # nat : pair bool (pair int (pair int @parameter%withdraw)) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PUSH nat 1000000000000; # nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PUSH mutez 1; # mutez : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + BALANCE; # mutez : mutez : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + EDIV; # option (pair nat mutez) : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + FAILWITH; # FAILED + }; # @some : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + CAR; # nat : nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + MUL; # nat : pair nat (pair bool (pair int (pair int @parameter%withdraw))) : mutez : @some : list operation : @storage + PAIR; # pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + DIG 4; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation + DUP; # @storage : @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation + DUG 5; # @storage : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + CDDAR; # address : pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + SELF; # contract (or (or (nat %borrow) (or (unit %default) (unit %liquidate))) (or (or (nat %repay) (option %setDelegate key_hash)) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (mutez %withdraw)))) : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + ADDRESS; # address : pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw))))) : mutez : @some : list operation : @storage + PAIR; # pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int @parameter%withdraw)))))) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : pair (pair nat (pair int bool)) (pair address (pair address int)) + }; # list operation : @storage + }; # list operation : @storage + PAIR; # pair (list operation) @storage + }; \ No newline at end of file diff --git a/smart_contracts/stability-fund.py b/smart_contracts/stability-fund.py new file mode 100644 index 00000000..d27ca19a --- /dev/null +++ b/smart_contracts/stability-fund.py @@ -0,0 +1,239 @@ +import smartpy as sp + +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") +Constants = sp.import_script_from_url("file:common/constants.py") +DevFund = sp.import_script_from_url("file:dev-fund.py") +Errors = sp.import_script_from_url("file:common/errors.py") + +################################################################ +# Contract +################################################################ + +# Extends `DeveloperFund` with the additional ability for the Administrator +# to liquidate Ovens. +class StabilityFundContract(DevFund.DevFundContract): + def __init__( + self, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + administratorContractAddress = Addresses.FUND_ADMINISTRATOR_ADDRESS, + ovenRegistryContractAddress = Addresses.OVEN_REGISTRY_ADDRESS, + tokenContractAddress = Addresses.TOKEN_ADDRESS, + ): + self.exception_optimization_level = "DefaultUnit" + + self.init( + governorContractAddress = governorContractAddress, + administratorContractAddress = administratorContractAddress, + tokenContractAddress = tokenContractAddress, + ovenRegistryContractAddress = ovenRegistryContractAddress + ) + + ################################################################ + # Administrator API + ################################################################ + + @sp.entry_point + def liquidate(self, ovenAddress): + sp.set_type(ovenAddress, sp.TAddress) + + # Verify the caller is the admin. + sp.verify(sp.sender == self.data.administratorContractAddress, message = Errors.NOT_ADMIN) + + # Verify the liquidation target is a trusted oven. + contractHandle = sp.contract( + sp.TAddress, + self.data.ovenRegistryContractAddress, + "isOven" + ).open_some() + sp.transfer(ovenAddress, sp.mutez(0), contractHandle) + + # Liquidate oven + contractHandle = sp.contract( + sp.TUnit, + ovenAddress, + "liquidate" + ).open_some() + sp.transfer(sp.unit, sp.mutez(0), contractHandle) + + ################################################################ + # Governance + ################################################################ + + # Update the oven registry contract. + @sp.entry_point + def setOvenRegistryContract(self, newOvenRegistryContractAddress): + sp.set_type(newOvenRegistryContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.ovenRegistryContractAddress = newOvenRegistryContractAddress + +# Only run tests if this file is main. +if __name__ == "__main__": + + ################################################################ + ################################################################ + # Tests + ################################################################ + ################################################################ + + DummyContract = sp.import_script_from_url("file:test-helpers/dummy-contract.py") + MockOvenProxy = sp.import_script_from_url("file:test-helpers/mock-oven-proxy.py") + Oven = sp.import_script_from_url("file:oven.py") + OvenRegistry = sp.import_script_from_url("file:oven-registry.py") + Token = sp.import_script_from_url("file:token.py") + + ################################################################ + # liquidate + ################################################################ + + @sp.add_test(name="liquidate - can liquidate oven") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND a mock oven proxy contract. + ovenProxy = MockOvenProxy.MockOvenProxyContract() + scenario += ovenProxy + + # AND an oven with a balance + balance = sp.mutez(12) + oven = Oven.OvenContract( + ovenProxyContractAddress = ovenProxy.address + ) + oven.set_initial_balance(balance) + scenario += oven + + # AND the oven is registered + scenario += ovenRegistry.addOven((oven.address, oven.address)).run( + sender = ovenFactoryAddress + ) + + # AND a StabilityFund contract + administrator = Addresses.FUND_ADMINISTRATOR_ADDRESS + fund = StabilityFundContract( + administratorContractAddress = administrator, + ovenRegistryContractAddress = ovenRegistry.address + ) + scenario += fund + + # WHEN liquidate is called by an address tht is not the administrator + scenario += fund.liquidate(oven.address).run( + sender = administrator, + ) + + # THEN the balance was transferred to the MockOvenProxy. + scenario.verify(ovenProxy.balance == balance) + + @sp.add_test(name="liquidate - fails if not called by admin") + def test(): + scenario = sp.test_scenario() + + # GIVEN an OvenRegistry contract + ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + ovenRegistry = OvenRegistry.OvenRegistryContract( + ovenFactoryContractAddress = ovenFactoryAddress + ) + scenario += ovenRegistry + + # AND an oven which is registered + ovenAddress = Addresses.OVEN_ADDRESS + scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + sender = ovenFactoryAddress + ) + + # AND a StabilityFund contract + administrator = Addresses.FUND_ADMINISTRATOR_ADDRESS + fund = StabilityFundContract( + administratorContractAddress = administrator, + ovenRegistryContractAddress = ovenRegistry.address + ) + scenario += fund + + # WHEN liquidate is called by an address that is not the administrator THEN the call fails. + notAdministrator = Addresses.NULL_ADDRESS + scenario += fund.liquidate(ovenAddress).run( + sender = notAdministrator, + valid = False, + ) + + # TODO(keefertaylor): Enable when SmartPy supports handling `failwith` in other contracts with `valid = False` + # SEE: https://t.me/SmartPy_io/6538@sp.add_test(name="oven-factory-withdraw - fails when not called from oven") + # @sp.add_test(name="liquidate - fails if not a trusted oven") + # def test(): + # scenario = sp.test_scenario() + + # # GIVEN an OvenRegistry contract + # ovenFactoryAddress = Addresses.OVEN_FACTORY_ADDRESS + # ovenRegistry = OvenRegistry.OvenRegistryContract( + # ovenFactoryContractAddress = ovenFactoryAddress + # ) + # scenario += ovenRegistry + + # # AND an oven which is registered + # ovenAddress = Addresses.OVEN_ADDRESS + # scenario += ovenRegistry.addOven((ovenAddress, ovenAddress)).run( + # sender = ovenFactoryAddress + # ) + + # # AND a StabilityFund contract + # administrator = Addresses.FUND_ADMINISTRATOR_ADDRESS + # fund = StabilityFundContract( + # administratorContractAddress = administrator, + # ovenRegistryContractAddress = ovenRegistry.address + # ) + # scenario += fund + + # # WHEN liquidate is passed an address which is not an oven THEN the call fails. + # notOvenAddress = Addresses.NULL_ADDRESS + # scenario += fund.liquidate(notOvenAddress).run( + # sender = administrator, + # valid = False, + # ) + + ################################################################ + # setOvenRegistryContract + ################################################################ + + @sp.add_test(name="setOvenRegistryContract - succeeds when called by governor") + def test(): + # GIVEN an DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = StabilityFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setOvenRegistryContract is called with a new contract + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += fund.setOvenRegistryContract(rotatedAddress).run( + sender = governorContractAddress, + ) + + # THEN the contract is updated. + scenario.verify(fund.data.ovenRegistryContractAddress == rotatedAddress) + + @sp.add_test(name="setOvenRegistryContract - fails when not called by governor") + def test(): + # GIVEN a DevFund contract + scenario = sp.test_scenario() + + governorContractAddress = Addresses.GOVERNOR_ADDRESS + fund = StabilityFundContract( + governorContractAddress = governorContractAddress + ) + scenario += fund + + # WHEN the setOvenRegistryContract is called by someone who isn't the governor THEN the call fails + rotatedAddress = Addresses.ROTATED_ADDRESS + scenario += fund.setOvenRegistryContract(rotatedAddress).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) \ No newline at end of file diff --git a/smart_contracts/stability-fund.tz b/smart_contracts/stability-fund.tz new file mode 100644 index 00000000..12b45d39 --- /dev/null +++ b/smart_contracts/stability-fund.tz @@ -0,0 +1,269 @@ +parameter (or (or (or (unit %default) (address %liquidate)) (or (pair %send mutez address) (pair %sendTokens nat address))) (or (or (address %setAdministratorContract) (option %setDelegate key_hash)) (or (address %setGovernorContract) (address %setOvenRegistryContract)))); +storage (pair (pair (address %administratorContractAddress) (address %governorContractAddress)) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + DROP; # @storage + # == default == # @storage + NIL operation; # list operation : @storage + } + { + SWAP; # @storage : @parameter%liquidate + # == liquidate == + # sp.verify(sp.sender == self.data.administratorContractAddress, message = 8) # @storage : @parameter%liquidate + DUP; # @storage : @storage : @parameter%liquidate + DUG 2; # @storage : @parameter%liquidate : @storage + CAAR; # address : @parameter%liquidate : @storage + SENDER; # address : address : @parameter%liquidate : @storage + COMPARE; # int : @parameter%liquidate : @storage + EQ; # bool : @parameter%liquidate : @storage + IF + {} + { + PUSH int 8; # int : @parameter%liquidate : @storage + FAILWITH; # FAILED + }; # @parameter%liquidate : @storage + # sp.transfer(params, sp.tez(0), sp.contract(sp.TAddress, self.data.ovenRegistryContractAddress, entry_point='isOven').open_some()) # @parameter%liquidate : @storage + NIL operation; # list operation : @parameter%liquidate : @storage + DIG 2; # @storage : list operation : @parameter%liquidate + DUP; # @storage : @storage : list operation : @parameter%liquidate + DUG 3; # @storage : list operation : @parameter%liquidate : @storage + CDAR; # address : list operation : @parameter%liquidate : @storage + CONTRACT %isOven address; # option (contract address) : list operation : @parameter%liquidate : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%liquidate : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%liquidate : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%liquidate : @storage + DIG 3; # @parameter%liquidate : mutez : @some : list operation : @storage + DUP; # @parameter%liquidate : @parameter%liquidate : mutez : @some : list operation : @storage + DUG 4; # @parameter%liquidate : mutez : @some : list operation : @parameter%liquidate : @storage + TRANSFER_TOKENS; # operation : list operation : @parameter%liquidate : @storage + CONS; # list operation : @parameter%liquidate : @storage + SWAP; # @parameter%liquidate : list operation : @storage + # sp.send(params, sp.tez(0)) # @parameter%liquidate : list operation : @storage + CONTRACT %liquidate unit; # option (contract unit) : list operation : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @storage + FAILWITH; # FAILED + }; # @some : list operation : @storage + PUSH mutez 0; # mutez : @some : list operation : @storage + UNIT; # unit : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%send + # == send == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%send + DUP; # @storage : @storage : @parameter%send + DUG 2; # @storage : @parameter%send : @storage + CADR; # address : @parameter%send : @storage + SENDER; # address : address : @parameter%send : @storage + COMPARE; # int : @parameter%send : @storage + EQ; # bool : @parameter%send : @storage + IF + {} + { + PUSH int 4; # int : @parameter%send : @storage + FAILWITH; # FAILED + }; # @parameter%send : @storage + # sp.send(sp.snd(params), sp.fst(params)) # @parameter%send : @storage + DUP; # @parameter%send : @parameter%send : @storage + CDR; # address : @parameter%send : @storage + CONTRACT unit; # option (contract unit) : @parameter%send : @storage + IF_SOME + {} + { + UNIT; # unit : @parameter%send : @storage + FAILWITH; # FAILED + }; # @some : @parameter%send : @storage + NIL operation; # list operation : @some : @parameter%send : @storage + SWAP; # @some : list operation : @parameter%send : @storage + DIG 2; # @parameter%send : @some : list operation : @storage + CAR; # mutez : @some : list operation : @storage + UNIT; # unit : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%sendTokens + # == sendTokens == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%sendTokens + DUP; # @storage : @storage : @parameter%sendTokens + DUG 2; # @storage : @parameter%sendTokens : @storage + CADR; # address : @parameter%sendTokens : @storage + SENDER; # address : address : @parameter%sendTokens : @storage + COMPARE; # int : @parameter%sendTokens : @storage + EQ; # bool : @parameter%sendTokens : @storage + IF + {} + { + PUSH int 4; # int : @parameter%sendTokens : @storage + FAILWITH; # FAILED + }; # @parameter%sendTokens : @storage + # sp.transfer(sp.record(from_ = sp.self_address, to_ = sp.snd(params), value = sp.fst(params)), sp.tez(0), sp.contract(sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress, value = sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.tokenContractAddress, entry_point='transfer').open_some()) # @parameter%sendTokens : @storage + NIL operation; # list operation : @parameter%sendTokens : @storage + DIG 2; # @storage : list operation : @parameter%sendTokens + DUP; # @storage : @storage : list operation : @parameter%sendTokens + DUG 3; # @storage : list operation : @parameter%sendTokens : @storage + CDDR; # address : list operation : @parameter%sendTokens : @storage + CONTRACT %transfer (pair (address %from) (pair (address %to) (nat %value))); # option (contract (pair (address %from) (pair (address %to) (nat %value)))) : list operation : @parameter%sendTokens : @storage + IF_SOME + {} + { + UNIT; # unit : list operation : @parameter%sendTokens : @storage + FAILWITH; # FAILED + }; # @some : list operation : @parameter%sendTokens : @storage + PUSH mutez 0; # mutez : @some : list operation : @parameter%sendTokens : @storage + DIG 3; # @parameter%sendTokens : mutez : @some : list operation : @storage + DUP; # @parameter%sendTokens : @parameter%sendTokens : mutez : @some : list operation : @storage + CAR; # nat : @parameter%sendTokens : mutez : @some : list operation : @storage + SWAP; # @parameter%sendTokens : nat : mutez : @some : list operation : @storage + CDR; # address : nat : mutez : @some : list operation : @storage + PAIR %to %value; # pair (address %to) (nat %value) : mutez : @some : list operation : @storage + SELF; # contract (or (or (or (unit %default) (address %liquidate)) (or (pair %send mutez address) (pair %sendTokens nat address))) (or (or (address %setAdministratorContract) (option %setDelegate key_hash)) (or (address %setGovernorContract) (address %setOvenRegistryContract)))) : pair (address %to) (nat %value) : mutez : @some : list operation : @storage + ADDRESS; # address : pair (address %to) (nat %value) : mutez : @some : list operation : @storage + PAIR %from; # pair (address %from) (pair (address %to) (nat %value)) : mutez : @some : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setAdministratorContract + # == setAdministratorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setAdministratorContract + DUP; # @storage : @storage : @parameter%setAdministratorContract + DUG 2; # @storage : @parameter%setAdministratorContract : @storage + CADR; # address : @parameter%setAdministratorContract : @storage + SENDER; # address : address : @parameter%setAdministratorContract : @storage + COMPARE; # int : @parameter%setAdministratorContract : @storage + EQ; # bool : @parameter%setAdministratorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setAdministratorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setAdministratorContract : @storage + SWAP; # @storage : @parameter%setAdministratorContract + # self.data.administratorContractAddress = params # @storage : @parameter%setAdministratorContract + DUP; # @storage : @storage : @parameter%setAdministratorContract + CDR; # pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @storage : @parameter%setAdministratorContract + SWAP; # @storage : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @parameter%setAdministratorContract + CADR; # address : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @parameter%setAdministratorContract + DIG 2; # @parameter%setAdministratorContract : address : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) + PAIR; # pair @parameter%setAdministratorContract address : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) + PAIR; # pair (pair @parameter%setAdministratorContract address) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + NIL operation; # list operation : pair (pair @parameter%setAdministratorContract address) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + } + { + SWAP; # @storage : @parameter%setDelegate + # == setDelegate == + # sp.verify(sp.sender == self.data.administratorContractAddress, message = 8) # @storage : @parameter%setDelegate + DUP; # @storage : @storage : @parameter%setDelegate + DUG 2; # @storage : @parameter%setDelegate : @storage + CAAR; # address : @parameter%setDelegate : @storage + SENDER; # address : address : @parameter%setDelegate : @storage + COMPARE; # int : @parameter%setDelegate : @storage + EQ; # bool : @parameter%setDelegate : @storage + IF + {} + { + PUSH int 8; # int : @parameter%setDelegate : @storage + FAILWITH; # FAILED + }; # @parameter%setDelegate : @storage + # sp.set_delegate(params) # @parameter%setDelegate : @storage + SET_DELEGATE; # operation : @storage + NIL operation; # list operation : operation : @storage + SWAP; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : pair (pair @parameter%setAdministratorContract address) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CADR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CDR; # pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @storage : @parameter%setGovernorContract + SWAP; # @storage : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @parameter%setGovernorContract + CAAR; # address : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) : @parameter%setGovernorContract + DIG 2; # @parameter%setGovernorContract : address : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) + SWAP; # address : @parameter%setGovernorContract : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) + PAIR; # pair address @parameter%setGovernorContract : pair (address %ovenRegistryContractAddress) (address %tokenContractAddress) + PAIR; # pair (pair address @parameter%setGovernorContract) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + } + { + SWAP; # @storage : @parameter%setOvenRegistryContract + # == setOvenRegistryContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + DUG 2; # @storage : @parameter%setOvenRegistryContract : @storage + CADR; # address : @parameter%setOvenRegistryContract : @storage + SENDER; # address : address : @parameter%setOvenRegistryContract : @storage + COMPARE; # int : @parameter%setOvenRegistryContract : @storage + EQ; # bool : @parameter%setOvenRegistryContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setOvenRegistryContract : @storage + FAILWITH; # FAILED + }; # @parameter%setOvenRegistryContract : @storage + SWAP; # @storage : @parameter%setOvenRegistryContract + # self.data.ovenRegistryContractAddress = params # @storage : @parameter%setOvenRegistryContract + DUP; # @storage : @storage : @parameter%setOvenRegistryContract + CAR; # pair (address %administratorContractAddress) (address %governorContractAddress) : @storage : @parameter%setOvenRegistryContract + SWAP; # @storage : pair (address %administratorContractAddress) (address %governorContractAddress) : @parameter%setOvenRegistryContract + CDDR; # address : pair (address %administratorContractAddress) (address %governorContractAddress) : @parameter%setOvenRegistryContract + DIG 2; # @parameter%setOvenRegistryContract : address : pair (address %administratorContractAddress) (address %governorContractAddress) + PAIR; # pair @parameter%setOvenRegistryContract address : pair (address %administratorContractAddress) (address %governorContractAddress) + SWAP; # pair (address %administratorContractAddress) (address %governorContractAddress) : pair @parameter%setOvenRegistryContract address + PAIR; # pair (pair (address %administratorContractAddress) (address %governorContractAddress)) (pair @parameter%setOvenRegistryContract address) + }; # pair (pair address @parameter%setGovernorContract) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + NIL operation; # list operation : pair (pair address @parameter%setGovernorContract) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + }; # list operation : pair (pair @parameter%setAdministratorContract address) (pair (address %ovenRegistryContractAddress) (address %tokenContractAddress)) + }; # list operation : @storage + NIL operation; # list operation : list operation : @storage + SWAP; # list operation : list operation : @storage + ITER + { + CONS; # list operation : @storage + }; # list operation : @storage + PAIR; # pair (list operation) @storage + }; \ No newline at end of file diff --git a/smart_contracts/test-helpers/addresses.py b/smart_contracts/test-helpers/addresses.py new file mode 100644 index 00000000..7848ad79 --- /dev/null +++ b/smart_contracts/test-helpers/addresses.py @@ -0,0 +1,54 @@ +import smartpy as sp + +# This file contains addresses for tests which are named and ensure uniqueness across the test suite. + +# The address which acts as the Governor +GOVERNOR_ADDRESS = sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf") + +# The address which acts as the OvenProxy. +OVEN_PROXY_ADDRESS = sp.address("tz1c461F8GirBvq5DpFftPoPyCcPR7HQM6gm") + +# The address which acts as the OvenRegistry +OVEN_REGISTRY_ADDRESS = sp.address("tz1hAYfexyzPGG6RhZZMpDvAHifubsbb6kgn") + +# The address which acts as the OvenFactory +OVEN_FACTORY_ADDRESS = sp.address("tz1irJKkXS2DBWkU1NnmFQx1c1L7pbGg4yhk") + +# The address which acts as an Oven +OVEN_ADDRESS = sp.address("tz1LmaFsWRkjr7QMCx5PtV6xTUz3AmEpKQiF") + +# The address which owns an Oven +OVEN_OWNER_ADDRESS = sp.address("tz1S8MNvuFEUsWgjHvi3AxibRBf388NhT1q2") + +# The address of an entity which performs a liquidation. +LIQUIDATOR_ADDRESS = sp.address("tz1LcuQHNVQEWP2fZjk1QYZGNrfLDwrT3SyZ") + +# The address that acts as the token contract. +TOKEN_ADDRESS = sp.address("tz1cYufsxHXJcvANhvS55h3aY32a9BAFB494") + +# The address which acts as the Oracle. +ORACLE_ADDRESS = sp.address("tz1P2Po7YM526ughEsRbY4oR9zaUPDZjxFrb") + +# The address wich acts as a Minter. +MINTER_ADDRESS = sp.address("tz1UUgPwikRHW1mEyVZfGYy6QaxrY6Y7WaG5") + +# An address which represents a Harbinger Oracle. +HARBINGER_ADDRESS = sp.address("tz1TDSmoZXwVevLTEvKCTHWpomG76oC9S2fJ") + +# An address which acts as a Fund Administrator. +FUND_ADMINISTRATOR_ADDRESS = sp.address("tz1VmiY38m3y95HqQLjMwqnMS7sdMfGomzKi") + +# An address which acts as a Stability Fund. +STABILITY_FUND_ADDRESS = sp.address("tz1W5VkdB5s7ENMESVBtwyt9kyvLqPcUczRT") + +# An address which acts as a Developer Fund +DEVELOPER_FUND_ADDRESS =sp.address("tz1R6Ej25VSerE3MkSoEEeBjKHCDTFbpKuSX") + +# An address which can be rotated. +ROTATED_ADDRESS = sp.address("tz1UMCB2AHSTwG7YcGNr31CqYCtGN873royv") + +# An address which acts as a pause guardian. +PAUSE_GUARDIAN_ADDRESS = sp.address("tz1LLNkQK4UQV6QcFShiXJ2vT2ELw449MzAA") + +# An address which is never used. This is a `null` value for addresses. +NULL_ADDRESS = sp.address("tz1bTpviNnyx2PXsNmGpCQTMQsGoYordkUoA") diff --git a/smart_contracts/test-helpers/compile.sh b/smart_contracts/test-helpers/compile.sh new file mode 100755 index 00000000..cfe41ea4 --- /dev/null +++ b/smart_contracts/test-helpers/compile.sh @@ -0,0 +1,74 @@ +#!/usr/bin/env bash + +set -e -o pipefail + +echo "----------------------------------------" +echo "Compiling StableCoin Contracts" +echo "----------------------------------------" + +# Expected location of SmartPy CLI. +SMART_PY_CLI=~/smartpy-cli/SmartPy.sh + +# Output directory +OUT_DIR=./.smartpy_out + +# Parallel sorted arrays. +CONTRACTS_ARRAY=(mock-oven-proxy fake-harbinger dummy-contract mock-minter) +INVOCATION_ARRAY=("MockOvenProxyContract()" "FakeHarbingerContract()" "DummyContract()" "MockMinterContract()") + +# Ensure we have a SmartPy binary. +if [ ! -f "$SMART_PY_CLI" ]; then + echo "Fatal: Please install SmartPy CLI at $SMART_PY_CLI" && exit +fi + +# Compile a contract. +# Args +function processContract { + CONTRACT_NAME=$1 + INVOCATION=$2 + OUT_DIR=$3 + CONTRACT_IN="${CONTRACT_NAME}.py" + CONTRACT_OUT="${CONTRACT_NAME}.tz" + CONTRACT_COMPILED="${CONTRACT_NAME}_compiled.tz" + + echo ">> Processing ${CONTRACT_NAME}" + + # Ensure file exists. + if [ ! -f "$CONTRACT_IN" ]; then + echo "Fatal: $CONTRACT_IN not found. Running from wrong dir?" && exit + fi + + # Test + echo ">>> [1 / 3] Testing ${CONTRACT_NAME} " + $SMART_PY_CLI test $CONTRACT_IN $OUT_DIR + echo ">>> Done" + + echo ">>> [2 / 3] Compiling ${CONTRACT_NAME}" + $SMART_PY_CLI compile $CONTRACT_IN $INVOCATION $OUT_DIR + echo ">>> Done." + + echo ">>> [3 / 3] Copying Artifacts" + cp $OUT_DIR/$CONTRACT_COMPILED $CONTRACT_OUT + echo ">>> Written to ${CONTRACT_OUT}" + echo "" +} + +echo "> [1 / 2] Compiling Contracts." +for i in ${!CONTRACTS_ARRAY[@]}; do + echo ">> [$((i + 1)) / ${#CONTRACTS_ARRAY[@]}] Processing ${CONTRACTS_ARRAY[$i]}" + processContract ${CONTRACTS_ARRAY[$i]} ${INVOCATION_ARRAY[$i]} $OUT_DIR + echo ">> Done." + echo "" +done +echo "> Compilation Complete." +echo "" + +# Remove other artifacts to reduce noise. +echo "> [2 / 2] Cleaning up" +# rm -rf $OUT_DIR +echo "> All tidied up." +echo "" + +echo "----------------------------------------" +echo "Task complete." +echo "----------------------------------------" diff --git a/smart_contracts/test-helpers/dummy-contract.py b/smart_contracts/test-helpers/dummy-contract.py new file mode 100644 index 00000000..79d0995f --- /dev/null +++ b/smart_contracts/test-helpers/dummy-contract.py @@ -0,0 +1,32 @@ +import smartpy as sp + +# A dummy contract which can receive and store data for introspection. +# +# This contract can be used in test as a way to capture the results of contract callbacks. +class DummyContract(sp.Contract): + def __init__( + self, + natValue = sp.nat(0), + intValue = sp.int(0), + ): + self.init( + natValue = natValue, + intValue = intValue, + ) + + # Default entrypoint always accepts transfers. + @sp.entry_point + def default(self, unit): + pass + + # Callback for a nat parameter. Places returned value in `natStorage`. + @sp.entry_point + def natCallback(self, newNatValue): + self.data.natValue = newNatValue + + # Callback for a int parameter. Places returned value in `intStorage`. + @sp.entry_point + def intCallback(self, newIntValue): + self.data.intValue = newIntValue + + diff --git a/smart_contracts/test-helpers/dummy-contract.tz b/smart_contracts/test-helpers/dummy-contract.tz new file mode 100644 index 00000000..661359c5 --- /dev/null +++ b/smart_contracts/test-helpers/dummy-contract.tz @@ -0,0 +1,34 @@ +parameter (or (unit %default) (or (int %intCallback) (nat %natCallback))); +storage (pair (int %intValue) (nat %natValue)); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + DROP; # @storage + # == default == # @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%intCallback + # == intCallback == + # self.data.intValue = params # @storage : @parameter%intCallback + CDR; # nat : @parameter%intCallback + SWAP; # @parameter%intCallback : nat + PAIR; # pair @parameter%intCallback nat + } + { + SWAP; # @storage : @parameter%natCallback + # == natCallback == + # self.data.natValue = params # @storage : @parameter%natCallback + CAR; # int : @parameter%natCallback + PAIR; # pair int @parameter%natCallback + }; # pair @parameter%intCallback nat + }; # @storage + NIL operation; # list operation : @storage + PAIR; # pair (list operation) @storage + }; \ No newline at end of file diff --git a/smart_contracts/test-helpers/fake-harbinger.py b/smart_contracts/test-helpers/fake-harbinger.py new file mode 100644 index 00000000..b38d8267 --- /dev/null +++ b/smart_contracts/test-helpers/fake-harbinger.py @@ -0,0 +1,37 @@ +import smartpy as sp + +Constants = sp.import_script_from_url("file:common/constants.py") + +# A contract which fakes a Harbinger oracle. +class FakeHarbingerContract(sp.Contract): + def __init__( + self, + harbingerValue = sp.nat(0), + harbingerUpdateTime = sp.timestamp(0), + harbingerAsset = Constants.ASSET_CODE + ): + self.init( + harbingerValue = harbingerValue, + harbingerUpdateTime = harbingerUpdateTime, + harbingerAsset = harbingerAsset, + ) + + # Update the asset price. + @sp.entry_point + def setNewPrice(self, newValue): + self.data.harbingerValue = newValue + + # Update - Not implemented + @sp.entry_point + def update(self, updateMap): + pass + + # Get - Returns the static value in the initializer + @sp.entry_point + def get(self, requestPair): + sp.set_type(requestPair, sp.TPair(sp.TString, sp.TContract(Constants.HARBINGER_DATA_TYPE))) + + callback = sp.snd(requestPair) + + result = (self.data.harbingerAsset, (self.data.harbingerUpdateTime, self.data.harbingerValue)) + sp.transfer(result, sp.mutez(0), callback) \ No newline at end of file diff --git a/smart_contracts/test-helpers/fake-harbinger.tz b/smart_contracts/test-helpers/fake-harbinger.tz new file mode 100644 index 00000000..01111259 --- /dev/null +++ b/smart_contracts/test-helpers/fake-harbinger.tz @@ -0,0 +1,39 @@ +parameter (or (pair %get string (contract (pair string (pair timestamp nat)))) (unit %update)); +storage (pair (string %harbingerAsset) (pair (timestamp %harbingerUpdateTime) (nat %harbingerValue))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + # == get == + # sp.transfer((self.data.harbingerAsset, (self.data.harbingerUpdateTime, self.data.harbingerValue)), sp.tez(0), sp.snd(params)) # @parameter%get : @storage + CDR; # contract (pair string (pair timestamp nat)) : @storage + NIL operation; # list operation : contract (pair string (pair timestamp nat)) : @storage + SWAP; # contract (pair string (pair timestamp nat)) : list operation : @storage + PUSH mutez 0; # mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + DIG 3; # @storage : mutez : contract (pair string (pair timestamp nat)) : list operation + DUP; # @storage : @storage : mutez : contract (pair string (pair timestamp nat)) : list operation + CDDR; # nat : @storage : mutez : contract (pair string (pair timestamp nat)) : list operation + SWAP; # @storage : nat : mutez : contract (pair string (pair timestamp nat)) : list operation + DUP; # @storage : @storage : nat : mutez : contract (pair string (pair timestamp nat)) : list operation + DUG 5; # @storage : nat : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + CDAR; # timestamp : nat : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + PAIR; # pair timestamp nat : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + DIG 4; # @storage : pair timestamp nat : mutez : contract (pair string (pair timestamp nat)) : list operation + DUP; # @storage : @storage : pair timestamp nat : mutez : contract (pair string (pair timestamp nat)) : list operation + DUG 5; # @storage : pair timestamp nat : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + CAR; # string : pair timestamp nat : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + PAIR; # pair string (pair timestamp nat) : mutez : contract (pair string (pair timestamp nat)) : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + DROP; # @storage + # == update == # @storage + NIL operation; # list operation : @storage + }; # list operation : @storage + PAIR; # pair (list operation) @storage + }; \ No newline at end of file diff --git a/smart_contracts/test-helpers/mock-minter.py b/smart_contracts/test-helpers/mock-minter.py new file mode 100644 index 00000000..662ce2d5 --- /dev/null +++ b/smart_contracts/test-helpers/mock-minter.py @@ -0,0 +1,136 @@ +# Partial mock of the Minter contract and captures values for inspection. + +import smartpy as sp + +Addresses = sp.import_script_from_url("file:./test-helpers/addresses.py") +OvenApi = sp.import_script_from_url("file:./common/oven-api.py") + +class MockMinterContract(sp.Contract): + def __init__( + self, + ): + self.init( + # borrow parameters. + borrow_oracleValue = sp.nat(0), + borrow_ovenAddress = Addresses.NULL_ADDRESS, + borrow_ownerAddress = Addresses.NULL_ADDRESS, + borrow_ovenBalance = sp.nat(0), + borrow_borrowedTokens = sp.nat(0), + borrow_liquidated = sp.bool(False), + borrow_stabilityFeeTokens = sp.int(0), + borrow_ovenInterestIndex = sp.int(0), + borrow_tokensToBorrow = sp.nat(0), + + # repay parameters. + repay_ovenAddress = Addresses.NULL_ADDRESS, + repay_ownerAddress = Addresses.NULL_ADDRESS, + repay_ovenBalance = sp.nat(0), + repay_borrowedTokens = sp.nat(0), + repay_liquidated = sp.bool(False), + repay_stabilityFeeTokens = sp.int(0), + repay_ovenInterestIndex = sp.int(0), + repay_tokensToRepay = sp.nat(0), + + # deposit parameters + deposit_ovenAddress = Addresses.NULL_ADDRESS, + deposit_ownerAddress = Addresses.NULL_ADDRESS, + deposit_ovenBalance = sp.nat(0), + deposit_borrowedTokens = sp.nat(0), + deposit_liquidated = sp.bool(False), + deposit_stabilityFeeTokens = sp.int(0), + deposit_ovenInterestIndex = sp.int(0), + + # withdraw parameters + withdraw_oracleValue = sp.nat(0), + withdraw_ovenAddress = Addresses.NULL_ADDRESS, + withdraw_ownerAddress = Addresses.NULL_ADDRESS, + withdraw_ovenBalance = sp.nat(0), + withdraw_borrowedTokens = sp.nat(0), + withdraw_liquidated = sp.bool(False), + withdraw_stabilityFeeTokens = sp.int(0), + withdraw_ovenInterestIndex = sp.int(0), + withdraw_mutezToWithdraw = sp.mutez(0), + + # liquidate parameters + liquidate_oracleValue = sp.nat(0), + liquidate_ovenAddress = Addresses.NULL_ADDRESS, + liquidate_ownerAddress = Addresses.NULL_ADDRESS, + liquidate_ovenBalance = sp.nat(0), + liquidate_borrowedTokens = sp.nat(0), + liquidate_liquidated = sp.bool(False), + liquidate_stabilityFeeTokens = sp.int(0), + liquidate_ovenInterestIndex = sp.int(0), + liquidate_liquidatorAddress = Addresses.NULL_ADDRESS, + ) + + ################################################################ + # Oven Interface + ################################################################ + + @sp.entry_point + def borrow(self, param): + sp.set_type(param, OvenApi.BORROW_PARAMETER_TYPE_ORACLE) + + self.data.borrow_oracleValue = sp.fst(param) + self.data.borrow_ovenAddress = sp.fst(sp.snd(param)) + self.data.borrow_ownerAddress = sp.fst(sp.snd(sp.snd(param))) + self.data.borrow_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.borrow_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.borrow_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.borrow_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.borrow_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + self.data.borrow_tokensToBorrow = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + + @sp.entry_point + def repay(self, param): + sp.set_type(param, OvenApi.REPAY_PARAMETER_TYPE) + + self.data.repay_ovenAddress = sp.fst(param) + self.data.repay_ownerAddress = sp.fst(sp.snd(param)) + self.data.repay_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.repay_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.repay_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.repay_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.repay_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.repay_tokensToRepay = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + + @sp.entry_point + def deposit(self, param): + sp.set_type(param, OvenApi.DEPOSIT_PARAMETER_TYPE) + + self.data.deposit_ovenAddress = sp.fst(param) + self.data.deposit_ownerAddress = sp.fst(sp.snd(param)) + self.data.deposit_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.deposit_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.deposit_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.deposit_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.deposit_ovenInterestIndex = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + + @sp.entry_point + def withdraw(self, param): + sp.set_type(param, OvenApi.WITHDRAW_PARAMETER_TYPE_ORACLE) + + self.data.withdraw_oracleValue = sp.fst(param) + self.data.withdraw_ovenAddress = sp.fst(sp.snd(param)) + self.data.withdraw_ownerAddress = sp.fst(sp.snd(sp.snd(param))) + self.data.withdraw_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.withdraw_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.withdraw_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.withdraw_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.withdraw_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + self.data.withdraw_mutezToWithdraw = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + + @sp.entry_point + def liquidate(self, param): + sp.set_type(param, OvenApi.LIQUIDATE_PARAMETER_TYPE_ORACLE) + + self.data.liquidate_oracleValue = sp.fst(param) + self.data.liquidate_ovenAddress = sp.fst(sp.snd(param)) + self.data.liquidate_ownerAddress = sp.fst(sp.snd(sp.snd(param))) + self.data.liquidate_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.liquidate_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.liquidate_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.liquidate_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.liquidate_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + self.data.liquidate_liquidatorAddress = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))))) + \ No newline at end of file diff --git a/smart_contracts/test-helpers/mock-minter.tz b/smart_contracts/test-helpers/mock-minter.tz new file mode 100644 index 00000000..428da06f --- /dev/null +++ b/smart_contracts/test-helpers/mock-minter.tz @@ -0,0 +1,1348 @@ +parameter (or (or (pair %borrow nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat)))))))) (pair %deposit address (pair address (pair nat (pair nat (pair bool (pair int int))))))) (or (pair %liquidate nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int address)))))))) (or (pair %repay address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) (pair %withdraw nat (pair address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez))))))))))); +storage (pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%borrow + # == borrow == + # self.data.borrow_oracleValue = sp.fst(params) # @storage : @parameter%borrow + DUP; # @storage : @storage : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%borrow + SWAP; # @storage : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # nat : pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_ovenAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # nat : pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair nat (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)) : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDAR; # address : nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : pair address nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat (pair address nat) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair nat (pair address nat) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_ownerAddress = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CADR; # int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDAR; # address : int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair nat (pair address nat) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair nat (pair address nat) : pair nat (pair address nat) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # nat : pair nat (pair address nat) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair nat (pair address nat) : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDAR; # address : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : address : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : address : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : address : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDAR; # nat : address : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # address : nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address nat : nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : pair address nat : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat (pair address nat) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair nat (pair address nat) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair nat (pair address nat)) : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CADR; # bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDAR; # nat : bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair nat (pair address nat) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair nat (pair address nat)) : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAAR; # nat : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : nat : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : nat : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDDAR; # bool : nat : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat bool : pair nat (pair address nat) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAAR; # address : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : address : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : address : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : address : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDDDAR; # int : address : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # address : int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address int : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair address int : pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair address int) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # nat : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDDDDAR; # int : nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair int nat : nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : pair int nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat (pair int nat) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair address int : pair nat (pair int nat) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair address int) (pair nat (pair int nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair nat (pair int nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_tokensToBorrow = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair address int) (pair nat (pair int nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair address int) (pair nat (pair int nat)) : pair (pair address int) (pair nat (pair int nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair address int : pair (pair address int) (pair nat (pair int nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair address int) (pair nat (pair int nat)) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # pair int nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : pair int nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDDDR; # nat : pair int nat : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair nat (pair int nat) : pair address int : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair address int : pair nat (pair int nat) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair address int) (pair nat (pair int nat)) : pair (pair nat bool) (pair nat (pair address nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair nat bool) (pair nat (pair address nat)) : pair (pair address int) (pair nat (pair int nat)) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + SWAP; # @storage : @parameter%deposit + # == deposit == + # self.data.deposit_ovenAddress = sp.fst(params) # @storage : @parameter%deposit + DUP; # @storage : @storage : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%deposit + SWAP; # @storage : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAAR; # bool : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : bool : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : bool : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : bool : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # address : bool : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # bool : address : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair bool address : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair bool address : pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair bool address) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # nat : pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)) : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%deposit : int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDAR; # address : int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair address int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair bool address : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDAR; # nat : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))) : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # nat : pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)) : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDAR; # int : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : int : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : int : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%deposit : int : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDAR; # nat : int : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # int : nat : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair int nat : nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : pair int nat : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair int nat) : pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens) : pair nat (pair int nat) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance))) : pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair nat (pair address int) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CADR; # address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDDAR; # bool : address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair bool address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair bool address : pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair nat (pair address int) : pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # nat : pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair nat (pair address int) : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDAR; # address : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : address : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : address : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%deposit : address : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDDDAR; # int : address : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # address : int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair address int : nat : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : pair address int : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_vaultInterestIndex = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CADR; # pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDR; # int : pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat))) : pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair nat (pair int nat)))) (pair (pair (pair bool address) (pair nat (pair address int))) (pair (pair int (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%liquidate + # == liquidate == + # self.data.liquidate_oracleValue = sp.fst(params) # @storage : @parameter%liquidate + DUP; # @storage : @storage : @parameter%liquidate + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%liquidate + SWAP; # @storage : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # bool : pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)) : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # nat : address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # bool : pair nat address : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair bool (pair nat address) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_ovenAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair bool (pair nat address) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair bool (pair nat address) : pair bool (pair nat address) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # bool : pair bool (pair nat address) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair bool (pair nat address) : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # nat : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : nat : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : nat : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : nat : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # address : nat : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # nat : address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat address : bool : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # bool : pair nat address : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair bool (pair nat address) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_ownerAddress = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CAAR; # nat : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : nat : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) + DUP; # @parameter%liquidate : @parameter%liquidate : nat : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) + DUG 6; # @parameter%liquidate : nat : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDDAR; # address : nat : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # nat : address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair nat address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CADR; # address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) + DUP; # @parameter%liquidate : @parameter%liquidate : address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) + DUG 6; # @parameter%liquidate : address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + CDDDAR; # nat : address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair nat address : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair bool (pair nat address) : pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair bool (pair nat address)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # int : pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens)) : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # address : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : address : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : address : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : address : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDDDAR; # nat : address : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # address : nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair address nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # int : pair address nat : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair int (pair address nat) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # pair nat address : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : pair nat address : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : pair nat address : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%liquidate : pair nat address : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDDDDAR; # bool : pair nat address : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair bool (pair nat address) : pair int (pair address nat) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair nat address : pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair nat address) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDDR; # pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) + DUP; # @parameter%liquidate : @parameter%liquidate : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) + DUG 6; # @parameter%liquidate : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDDDDDDAR; # int : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair nat address : pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # pair nat address : pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair nat address) (pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDR; # pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DUP; # pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CAR; # int : pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair int (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDDR; # nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) + DUP; # @parameter%liquidate : @parameter%liquidate : nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) + DUG 7; # @parameter%liquidate : nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + CDDDDDDDAR; # int : nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair int nat : int : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # int : pair int nat : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair int (pair int nat) : pair nat address : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair nat address : pair int (pair int nat) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair nat address) (pair int (pair int nat)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_beneficiaryAddress = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair bool (pair nat address) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair int (pair address nat) : pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # int : pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair int (pair address nat) : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDDDR; # address : nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair address nat : int : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # int : pair address nat : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int (pair address nat) : pair bool (pair nat address) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens))) : pair (pair int (pair address nat)) (pair bool (pair nat address)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens)))) : pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address)))) : pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%repay + # == repay == + # self.data.repay_ovenAddress = sp.fst(params) # @storage : @parameter%repay + DUP; # @storage : @storage : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @storage : @parameter%repay + SWAP; # @storage : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAAR; # bool : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 5; # @parameter%repay : bool : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : bool : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%repay : bool : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # address : bool : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # bool : address : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair bool address : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair bool address : pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair bool address) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # nat : pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)) : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDR; # int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 6; # @parameter%repay : int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%repay : int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDAR; # address : int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair address int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # nat : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair bool address : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDR; # pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 5; # @parameter%repay : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%repay : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDAR; # nat : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens))) : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # int : pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDAR; # int : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 6; # @parameter%repay : int : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : int : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%repay : int : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDDAR; # nat : int : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # int : nat : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair int nat : int : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # int : pair int nat : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair int (pair int nat) : pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress) : pair int (pair int nat) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair nat (pair address int) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CADR; # address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 5; # @parameter%repay : address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%repay : address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDDDAR; # bool : address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair bool address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair bool address) (pair nat (pair address int)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair bool address : pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair bool address) (pair nat (pair address int)) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair nat (pair address int) : pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # nat : pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair nat (pair address int) : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDAR; # address : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 6; # @parameter%repay : address : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : address : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%repay : address : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDDDDAR; # int : address : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # address : int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair address int : nat : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # nat : pair address int : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair nat (pair address int) : pair bool address : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair bool address : pair nat (pair address int) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair bool address) (pair nat (pair address int)) : pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat)) : pair (pair bool address) (pair nat (pair address int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAAR; # nat : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 5; # @parameter%repay : nat : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%repay : @parameter%repay : nat : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%repay : nat : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDDDDDDAR; # int : nat : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # nat : int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair nat int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_tokensToRepay = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CAR; # pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DUP; # pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CDR; # pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + SWAP; # pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + CADR; # int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%repay + DIG 5; # @parameter%repay : int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + CDDDDDDDR; # nat : int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair nat int : pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int))) : pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + SWAP; # @storage : @parameter%withdraw + # == withdraw == + # self.data.withdraw_oracleValue = sp.fst(params) # @storage : @parameter%withdraw + DUP; # @storage : @storage : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @storage : @parameter%withdraw + SWAP; # @storage : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CADR; # pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 5; # @parameter%withdraw : pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%withdraw : pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # nat : pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_ovenAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # nat : pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDR; # nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%withdraw : nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDAR; # address : nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair address nat : nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # nat : pair address nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair nat (pair address nat) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_ownerAddress = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair nat (pair address nat) : pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair nat (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDR; # pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 5; # @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDAR; # address : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_ovenBalance = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair nat (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair nat (pair address nat) : pair nat (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # nat : pair nat (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair address nat) : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDAR; # address : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : address : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : address : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%withdraw : address : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDDAR; # nat : address : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # address : nat : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair address nat : nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # nat : pair address nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair nat (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDR; # pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 5; # @parameter%withdraw : pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 6; # @parameter%withdraw : pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDDDAR; # nat : pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw))) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # nat : pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)) : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDR; # mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%withdraw : mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDDDDAR; # bool : mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair bool mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # nat : pair bool mutez : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair nat (pair bool mutez) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair nat (pair bool mutez) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair nat (pair address nat) : pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair nat (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # address : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDR; # int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDDDDDAR; # int : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair int int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # address : pair int int : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair address (pair int int) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair address nat) : pair address (pair int int) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + # self.data.withdraw_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair nat (pair address nat) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair address (pair int int) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair address (pair int int) : pair address (pair int int) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # address : pair address (pair int int) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair address (pair int int) : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDAR; # int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUP; # @parameter%withdraw : @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + DUG 7; # @parameter%withdraw : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDDDDDDDAR; # int : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # int : int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair int int : address : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # address : pair int int : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair address (pair int int) : pair nat (pair address nat) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair address nat) : pair address (pair int int) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + # self.data.withdraw_mutezToWithdraw = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDR; # pair nat (pair bool mutez) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DUP; # pair nat (pair bool mutez) : pair nat (pair bool mutez) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CAR; # nat : pair nat (pair bool mutez) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + SWAP; # pair nat (pair bool mutez) : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + CDAR; # bool : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : bool : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + CDDDDDDDDR; # mutez : bool : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # bool : mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair bool mutez : nat : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # nat : pair bool mutez : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair nat (pair bool mutez) : pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex) : pair nat (pair bool mutez) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez)) : pair (pair nat (pair address nat)) (pair address (pair int int)) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens)))) : pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + PAIR; # pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress))))) : pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int)))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair nat (pair bool mutez))) (pair (pair nat (pair address nat)) (pair address (pair int int))))) + }; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair int (pair int nat))) (pair (pair bool address) (pair nat (pair address int)))) (pair (pair (pair nat int) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (nat %borrow_oracleValue) (pair (address %borrow_ovenAddress) (nat %borrow_ovenBalance)))) (pair (pair (address %borrow_ownerAddress) (int %borrow_stabilityFeeTokens)) (pair (nat %borrow_tokensToBorrow) (pair (int %borrow_vaultInterestIndex) (nat %deposit_borrowedTokens))))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair int (pair address nat)) (pair bool (pair nat address))))) (pair (pair (pair (pair nat address) (pair int (pair int nat))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + NIL operation; # list operation : pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + PAIR; # pair (list operation) (pair (pair (pair (pair (pair nat bool) (pair nat (pair address nat))) (pair (pair address int) (pair nat (pair int nat)))) (pair (pair (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) (pair (nat %deposit_ovenBalance) (pair (address %deposit_ownerAddress) (int %deposit_stabilityFeeTokens)))) (pair (pair (int %deposit_vaultInterestIndex) (pair (address %liquidate_beneficiaryAddress) (nat %liquidate_borrowedTokens))) (pair (bool %liquidate_liquidated) (pair (nat %liquidate_oracleValue) (address %liquidate_ovenAddress)))))) (pair (pair (pair (pair (nat %liquidate_ovenBalance) (address %liquidate_ownerAddress)) (pair (int %liquidate_stabilityFeeTokens) (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)))) (pair (pair (bool %repay_liquidated) (address %repay_ovenAddress)) (pair (nat %repay_ovenBalance) (pair (address %repay_ownerAddress) (int %repay_stabilityFeeTokens))))) (pair (pair (pair (nat %repay_tokensToRepay) (int %repay_vaultInterestIndex)) (pair (nat %withdraw_borrowedTokens) (pair (bool %withdraw_liquidated) (mutez %withdraw_mutezToWithdraw)))) (pair (pair (nat %withdraw_oracleValue) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))))) + }; \ No newline at end of file diff --git a/smart_contracts/test-helpers/mock-oven-proxy.py b/smart_contracts/test-helpers/mock-oven-proxy.py new file mode 100644 index 00000000..c54851af --- /dev/null +++ b/smart_contracts/test-helpers/mock-oven-proxy.py @@ -0,0 +1,146 @@ +# Partial mock of the OvenProxy contract and captures values for inspection. + +import smartpy as sp + +Addresses = sp.import_script_from_url("file:./test-helpers/addresses.py") +OvenApi = sp.import_script_from_url("file:./common/oven-api.py") + +class MockOvenProxyContract(sp.Contract): + def __init__( + self, + ): + self.init( + # borrow parameters. + borrow_ovenAddress = Addresses.NULL_ADDRESS, + borrow_ownerAddress = Addresses.NULL_ADDRESS, + borrow_ovenBalance = sp.nat(0), + borrow_borrowedTokens = sp.nat(0), + borrow_liquidated = sp.bool(False), + borrow_stabilityFeeTokens = sp.int(0), + borrow_ovenInterestIndex = sp.int(0), + borrow_tokensToBorrow = sp.nat(0), + + # repay parameters. + repay_ovenAddress = Addresses.NULL_ADDRESS, + repay_ownerAddress = Addresses.NULL_ADDRESS, + repay_ovenBalance = sp.nat(0), + repay_borrowedTokens = sp.nat(0), + repay_liquidated = sp.bool(False), + repay_stabilityFeeTokens = sp.int(0), + repay_ovenInterestIndex = sp.int(0), + repay_tokensToRepay = sp.nat(0), + + # deposit parameters + deposit_ovenAddress = Addresses.NULL_ADDRESS, + deposit_ownerAddress = Addresses.NULL_ADDRESS, + deposit_ovenBalance = sp.nat(0), + deposit_borrowedTokens = sp.nat(0), + deposit_liquidated = sp.bool(False), + deposit_stabilityFeeTokens = sp.int(0), + deposit_ovenInterestIndex = sp.int(0), + + # withdraw parameters + withdraw_ovenAddress = Addresses.NULL_ADDRESS, + withdraw_ownerAddress = Addresses.NULL_ADDRESS, + withdraw_ovenBalance = sp.nat(0), + withdraw_borrowedTokens = sp.nat(0), + withdraw_liquidated = sp.bool(False), + withdraw_stabilityFeeTokens = sp.int(0), + withdraw_ovenInterestIndex = sp.int(0), + withdraw_mutezToWithdraw = sp.mutez(0), + + # liquidate parameters + liquidate_ovenAddress = Addresses.NULL_ADDRESS, + liquidate_ownerAddress = Addresses.NULL_ADDRESS, + liquidate_ovenBalance = sp.nat(0), + liquidate_borrowedTokens = sp.nat(0), + liquidate_liquidated = sp.bool(False), + liquidate_stabilityFeeTokens = sp.int(0), + liquidate_ovenInterestIndex = sp.int(0), + liquidate_liquidatorAddress = Addresses.NULL_ADDRESS, + + # updateState parameters + updateState_ovenAddress = Addresses.NULL_ADDRESS, + updateState_borrowedTokens = sp.nat(0), + updateState_stabilityFeeTokens = sp.int(0), + updateState_interestIndex = sp.int(0), + updateState_isLiquidated = False + ) + + ################################################################ + # Oven Interface + ################################################################ + + @sp.entry_point + def borrow(self, param): + sp.set_type(param, OvenApi.BORROW_PARAMETER_TYPE) + + self.data.borrow_ovenAddress = sp.fst(param) + self.data.borrow_ownerAddress = sp.fst(sp.snd(param)) + self.data.borrow_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.borrow_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.borrow_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.borrow_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.borrow_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.borrow_tokensToBorrow = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + + @sp.entry_point + def repay(self, param): + sp.set_type(param, OvenApi.REPAY_PARAMETER_TYPE) + + self.data.repay_ovenAddress = sp.fst(param) + self.data.repay_ownerAddress = sp.fst(sp.snd(param)) + self.data.repay_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.repay_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.repay_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.repay_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.repay_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.repay_tokensToRepay = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + + @sp.entry_point + def deposit(self, param): + sp.set_type(param, OvenApi.DEPOSIT_PARAMETER_TYPE) + + self.data.deposit_ovenAddress = sp.fst(param) + self.data.deposit_ownerAddress = sp.fst(sp.snd(param)) + self.data.deposit_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.deposit_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.deposit_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.deposit_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.deposit_ovenInterestIndex = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + + @sp.entry_point + def withdraw(self, param): + sp.set_type(param, OvenApi.WITHDRAW_PARAMETER_TYPE) + + self.data.withdraw_ovenAddress = sp.fst(param) + self.data.withdraw_ownerAddress = sp.fst(sp.snd(param)) + self.data.withdraw_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.withdraw_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.withdraw_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.withdraw_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.withdraw_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.withdraw_mutezToWithdraw = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + + @sp.entry_point + def liquidate(self, param): + sp.set_type(param, OvenApi.LIQUIDATE_PARAMETER_TYPE) + + self.data.liquidate_ovenAddress = sp.fst(param) + self.data.liquidate_ownerAddress = sp.fst(sp.snd(param)) + self.data.liquidate_ovenBalance = sp.fst(sp.snd(sp.snd(param))) + self.data.liquidate_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.liquidate_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(param))))) + self.data.liquidate_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param)))))) + self.data.liquidate_ovenInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + self.data.liquidate_liquidatorAddress = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(param))))))) + + @sp.entry_point + def updateState(self, param): + sp.set_type(param, OvenApi.UPDATE_STATE_PARAMETER_TYPE) + + self.data.updateState_ovenAddress = sp.fst(param) + self.data.updateState_borrowedTokens = sp.fst(sp.snd(param)) + self.data.updateState_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(param))) + self.data.updateState_interestIndex = sp.fst(sp.snd(sp.snd(sp.snd(param)))) + self.data.updateState_isLiquidated = sp.snd(sp.snd(sp.snd(sp.snd(param)))) \ No newline at end of file diff --git a/smart_contracts/test-helpers/mock-oven-proxy.tz b/smart_contracts/test-helpers/mock-oven-proxy.tz new file mode 100644 index 00000000..5ae14703 --- /dev/null +++ b/smart_contracts/test-helpers/mock-oven-proxy.tz @@ -0,0 +1,1432 @@ +parameter (or (or (pair %borrow address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) (or (pair %deposit address (pair address (pair nat (pair nat (pair bool (pair int int)))))) (pair %liquidate address (pair address (pair nat (pair nat (pair bool (pair int (pair int address))))))))) (or (pair %repay address (pair address (pair nat (pair nat (pair bool (pair int (pair int nat))))))) (or (pair %updateState address (pair nat (pair int (pair int bool)))) (pair %withdraw address (pair address (pair nat (pair nat (pair bool (pair int (pair int mutez)))))))))); +storage (pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%borrow + # == borrow == + # self.data.borrow_ovenAddress = sp.fst(params) # @storage : @parameter%borrow + DUP; # @storage : @storage : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%borrow + SWAP; # @storage : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # address : pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # address : pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair address (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)) : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDAR; # nat : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : nat : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : nat : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDAR; # address : nat : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # address : pair nat address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address (pair nat address) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair address (pair nat address) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair address (pair nat address) : pair address (pair nat address) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # address : pair address (pair nat address) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair address (pair nat address) : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDAR; # nat : address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat address : address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # address : pair nat address : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair address (pair nat address) : pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated) : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair address (pair nat address) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair address (pair nat address)) : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CADR; # bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDAR; # nat : bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair address (pair nat address) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair address (pair nat address)) : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAAR; # nat : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : nat : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : nat : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDAR; # bool : nat : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat bool : pair address (pair nat address) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CADR; # pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 5; # @parameter%borrow : pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%borrow : pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDDAR; # int : pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # int : pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair int (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDAR; # nat : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : nat : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%borrow : @parameter%borrow : nat : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%borrow : nat : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDDDDDAR; # int : nat : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # nat : int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair nat int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # int : pair nat int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair int (pair nat int) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + PAIR; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + # self.data.borrow_tokensToBorrow = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + DUP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDR; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # pair int (pair nat int) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DUP; # pair int (pair nat int) : pair int (pair nat int) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CAR; # int : pair int (pair nat int) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + SWAP; # pair int (pair nat int) : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + CDDR; # int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%borrow + DIG 6; # @parameter%borrow : int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDDR; # nat : int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair nat int : int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # int : pair nat int : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int (pair nat int) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair nat bool) (pair address (pair nat address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair nat bool) (pair address (pair nat address)) : pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%deposit + # == deposit == + # self.data.deposit_ovenAddress = sp.fst(params) # @storage : @parameter%deposit + DUP; # @storage : @storage : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%deposit + SWAP; # @storage : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # nat : pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)) : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDAR; # bool : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : bool : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : bool : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%deposit : bool : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # address : bool : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # bool : address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair bool address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair nat (pair bool address) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAAR; # nat : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : nat : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : nat : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : nat : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDAR; # address : nat : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CADR; # address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDAR; # nat : address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat address : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDAR; # nat : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair nat (pair bool address) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair nat (pair bool address) : pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # nat : pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair nat (pair bool address) : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%deposit : address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDDAR; # bool : address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair bool address : nat : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # nat : pair bool address : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair nat (pair bool address) : pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex)) : pair nat (pair bool address) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress))) : pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair nat address : pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair nat address) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 5; # @parameter%deposit : pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%deposit : @parameter%deposit : pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%deposit : pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDDDDAR; # int : pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair nat address : pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + # self.data.deposit_vaultInterestIndex = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # pair nat address : pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair (pair nat address) (pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDR; # pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DUP; # pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CAR; # int : pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + SWAP; # pair int (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : int : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + CDDR; # address : int : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%deposit + DIG 6; # @parameter%deposit : address : int : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDR; # int : address : int : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int address : int : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # int : pair int address : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int (pair int address) : pair nat address : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair nat address : pair int (pair int address) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair nat address) (pair int (pair int address)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair nat address) (pair int (pair int address))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address))) : pair (pair (pair nat address) (pair int (pair int address))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair int address))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair int address))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + SWAP; # @storage : @parameter%liquidate + # == liquidate == + # self.data.liquidate_ovenAddress = sp.fst(params) # @storage : @parameter%liquidate + DUP; # @storage : @storage : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @storage : @parameter%liquidate + SWAP; # @storage : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress)) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress)) : pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress)) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # nat : pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress)) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress)) : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # bool : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : bool : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : bool : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : bool : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # address : bool : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # bool : address : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair bool address : nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # nat : pair bool address : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair bool address) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair nat (pair bool address) : pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair nat (pair bool address)) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # nat : pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)) : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # address : int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair address int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # nat : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair nat (pair bool address) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%liquidate : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDAR; # nat : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair nat (pair address int) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CADR; # pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 6; # @parameter%liquidate : pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDDAR; # nat : pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair nat (pair address int) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair nat (pair bool address) : pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # nat : pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair nat (pair bool address) : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDR; # address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDDDAR; # bool : address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair bool address : nat : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # nat : pair bool address : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair nat (pair bool address) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair nat (pair address int) : pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # nat : pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair nat (pair address int) : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # address : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : address : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUP; # @parameter%liquidate : @parameter%liquidate : address : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + DUG 7; # @parameter%liquidate : address : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDDDDDAR; # int : address : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # address : int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair address int : nat : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # nat : pair address int : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair nat (pair address int) : pair nat (pair bool address) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair nat (pair bool address) : pair nat (pair address int) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CDR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + DUP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CDR; # pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CADR; # nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + DIG 5; # @parameter%liquidate : nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) + DUP; # @parameter%liquidate : @parameter%liquidate : nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) + DUG 6; # @parameter%liquidate : nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + CDDDDDDAR; # int : nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + PAIR; # pair int nat : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + PAIR; # pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + PAIR; # pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + # self.data.liquidate_beneficiaryAddress = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + CDR; # pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress))) : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDR; # pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DUP; # pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CAR; # int : pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + SWAP; # pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)) : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + CDAR; # int : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%liquidate + DIG 6; # @parameter%liquidate : int : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + CDDDDDDDR; # address : int : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # int : address : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int address : int : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # int : pair int address : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair int (pair int address) : pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress) : pair int (pair int address) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair int (pair int address)) : pair (pair nat (pair bool address)) (pair nat (pair address int)) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair int (pair int address))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + SWAP; # pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress)))) : pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair int (pair int address))) (pair (pair nat (pair bool address)) (pair nat (pair address int))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair int (pair int address))) (pair (pair nat (pair bool address)) (pair nat (pair address int)))) : pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair int (pair int address))) (pair (pair nat (pair bool address)) (pair nat (pair address int))))) (pair (pair (pair (pair int nat) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair nat (pair bool address)))) (pair (pair (pair nat address) (pair int (pair int address))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%repay + # == repay == + # self.data.repay_ovenAddress = sp.fst(params) # @storage : @parameter%repay + DUP; # @storage : @storage : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @storage : @parameter%repay + SWAP; # @storage : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # bool : pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)) : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDR; # nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 6; # @parameter%repay : nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%repay : nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # address : nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair address nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # bool : pair address nat : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair bool (pair address nat) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair bool (pair address nat) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CADR; # pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 5; # @parameter%repay : pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%repay : pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDAR; # address : pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair bool (pair address nat) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair bool (pair address nat) : pair bool (pair address nat) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # bool : pair bool (pair address nat) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair bool (pair address nat) : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDAR; # address : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 6; # @parameter%repay : address : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : address : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%repay : address : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDAR; # nat : address : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # address : nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair address nat : bool : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # bool : pair address nat : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair bool (pair address nat) : pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens) : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair bool (pair address nat) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair bool (pair address nat)) : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAAR; # int : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 5; # @parameter%repay : int : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : int : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%repay : int : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDDAR; # nat : int : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # int : nat : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair int nat : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair int nat : pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair int nat) (pair bool (pair address nat)) : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDR; # pair address nat : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 5; # @parameter%repay : pair address nat : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : pair address nat : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%repay : pair address nat : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDDDAR; # bool : pair address nat : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair bool (pair address nat) : pair int nat : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair int nat : pair bool (pair address nat) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # address : pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair address (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDR; # nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 6; # @parameter%repay : nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%repay : nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDDDDAR; # int : nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair int nat : address : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # address : pair int nat : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair address (pair int nat) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair address (pair int nat) : pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair address (pair int nat)) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDR; # pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 5; # @parameter%repay : pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%repay : @parameter%repay : pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%repay : pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDDDDDDAR; # int : pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair address (pair int nat) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair address (pair int nat) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + PAIR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%repay + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + # self.data.repay_tokensToRepay = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%repay + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDR; # pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # pair address (pair int nat) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DUP; # pair address (pair int nat) : pair address (pair int nat) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CAR; # address : pair address (pair int nat) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + SWAP; # pair address (pair int nat) : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + CDAR; # int : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%repay + DIG 6; # @parameter%repay : int : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + CDDDDDDDR; # nat : int : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # int : nat : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair int nat : address : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # address : pair int nat : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair address (pair int nat) : pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair int nat) (pair bool (pair address nat)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair int nat) (pair bool (pair address nat)) : pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateState + # == updateState == + # self.data.updateState_ovenAddress = sp.fst(params) # @storage : @parameter%updateState + DUP; # @storage : @storage : @parameter%updateState + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @storage : @parameter%updateState + SWAP; # @storage : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAAR; # bool : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DIG 5; # @parameter%updateState : bool : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%updateState : @parameter%updateState : bool : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%updateState : bool : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # address : bool : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # bool : address : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair bool address : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + # self.data.updateState_borrowedTokens = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # int : pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)) : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDDR; # int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DIG 6; # @parameter%updateState : int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%updateState : @parameter%updateState : int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%updateState : int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDAR; # nat : int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair nat int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # int : pair nat int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair int (pair nat int) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair int (pair nat int) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + # self.data.updateState_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair bool address : pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair bool address) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDDR; # pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DIG 5; # @parameter%updateState : pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%updateState : @parameter%updateState : pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%updateState : pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDDAR; # int : pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair bool address : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair bool address : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + # self.data.updateState_interestIndex = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair int (pair nat int) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair int (pair nat int) : pair int (pair nat int) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # int : pair int (pair nat int) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair int (pair nat int) : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDAR; # nat : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DIG 6; # @parameter%updateState : nat : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%updateState : @parameter%updateState : nat : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%updateState : nat : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDDDAR; # int : nat : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # nat : int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair nat int : int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # int : pair nat int : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair int (pair nat int) : pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay)) : pair int (pair nat int) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance))) : pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%updateState + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + # self.data.updateState_isLiquidated = sp.snd(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CAR; # pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DUP; # pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CDR; # pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + SWAP; # pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + CADR; # address : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%updateState + DIG 5; # @parameter%updateState : address : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + CDDDDR; # bool : address : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair bool address : pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int))) : pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + } + { + SWAP; # @storage : @parameter%withdraw + # == withdraw == + # self.data.withdraw_ovenAddress = sp.fst(params) # @storage : @parameter%withdraw + DUP; # @storage : @storage : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @storage : @parameter%withdraw + SWAP; # @storage : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # mutez : pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance)) : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDR; # nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # address : nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair address nat : mutez : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # mutez : pair address nat : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair mutez (pair address nat) : pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_ownerAddress = sp.fst(sp.snd(params)) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair mutez (pair address nat) : pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair mutez (pair address nat)) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDR; # pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 5; # @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 6; # @parameter%withdraw : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDAR; # address : pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair mutez (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_ovenBalance = sp.fst(sp.snd(sp.snd(params))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair mutez (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair mutez (pair address nat) : pair mutez (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # mutez : pair mutez (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair mutez (pair address nat) : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDAR; # address : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : address : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : address : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : address : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDAR; # nat : address : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # address : nat : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair address nat : mutez : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # mutez : pair address nat : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair mutez (pair address nat) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_borrowedTokens = sp.fst(sp.snd(sp.snd(sp.snd(params)))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated))) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # int : pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)) : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDR; # bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDDAR; # nat : bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair nat bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # int : pair nat bool : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair int (pair nat bool) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair int (pair nat bool) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_liquidated = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(params))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair int (pair nat bool) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair int (pair nat bool) : pair int (pair nat bool) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # int : pair int (pair nat bool) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair int (pair nat bool) : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDAR; # nat : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : nat : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : nat : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : nat : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDDDAR; # bool : nat : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # nat : bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair nat bool : int : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # int : pair nat bool : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair int (pair nat bool) : pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress) : pair int (pair nat bool) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + # self.data.withdraw_stabilityFeeTokens = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params)))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair mutez (pair address nat) : pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair mutez (pair address nat)) (pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # address : pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair address (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)) : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDR; # int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDDDDAR; # int : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair int int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # address : pair int int : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair address (pair int int) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair mutez (pair address nat) : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + # self.data.withdraw_vaultInterestIndex = sp.fst(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair mutez (pair address nat) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair address (pair int int) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair address (pair int int) : pair address (pair int int) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # address : pair address (pair int int) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair address (pair int int) : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDAR; # int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 6; # @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUP; # @parameter%withdraw : @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + DUG 7; # @parameter%withdraw : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDDDDDDAR; # int : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # int : int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair int int : address : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # address : pair int int : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair address (pair int int) : pair mutez (pair address nat) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair mutez (pair address nat) : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : @parameter%withdraw + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + # self.data.withdraw_mutezToWithdraw = sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(sp.snd(params))))))) # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + CAR; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CAR; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DUP; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CDR; # pair address (pair int int) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + SWAP; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + CADR; # pair address nat : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : @parameter%withdraw + DIG 5; # @parameter%withdraw : pair address nat : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + CDDDDDDDR; # mutez : pair address nat : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair mutez (pair address nat) : pair address (pair int int) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool)) : pair (pair mutez (pair address nat)) (pair address (pair int int)) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex)))) : pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + PAIR; # pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) : pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) + SWAP; # pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens))))) : pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int)))) + PAIR; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair int (pair nat bool))) (pair (pair mutez (pair address nat)) (pair address (pair int int))))) + }; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair int (pair nat int)))) (pair (pair (pair bool address) (pair int (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair (nat %borrow_borrowedTokens) (bool %borrow_liquidated)) (pair (address %borrow_ovenAddress) (pair (nat %borrow_ovenBalance) (address %borrow_ownerAddress)))) (pair (pair (int %borrow_stabilityFeeTokens) (pair (nat %borrow_tokensToBorrow) (int %borrow_vaultInterestIndex))) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair int nat) (pair bool (pair address nat))) (pair (pair address (pair int nat)) (pair int (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + }; # pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + NIL operation; # list operation : pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex)))))) + PAIR; # pair (list operation) (pair (pair (pair (pair (pair nat bool) (pair address (pair nat address))) (pair (pair int (pair nat int)) (pair (nat %deposit_borrowedTokens) (pair (bool %deposit_liquidated) (address %deposit_ovenAddress))))) (pair (pair (pair (nat %deposit_ovenBalance) (address %deposit_ownerAddress)) (pair (int %deposit_stabilityFeeTokens) (pair (int %deposit_vaultInterestIndex) (address %liquidate_beneficiaryAddress)))) (pair (pair (nat %liquidate_borrowedTokens) (pair (bool %liquidate_liquidated) (address %liquidate_ovenAddress))) (pair (nat %liquidate_ovenBalance) (pair (address %liquidate_ownerAddress) (int %liquidate_stabilityFeeTokens)))))) (pair (pair (pair (pair (int %liquidate_vaultInterestIndex) (nat %repay_borrowedTokens)) (pair (bool %repay_liquidated) (pair (address %repay_ovenAddress) (nat %repay_ovenBalance)))) (pair (pair (address %repay_ownerAddress) (pair (int %repay_stabilityFeeTokens) (nat %repay_tokensToRepay))) (pair (int %repay_vaultInterestIndex) (pair (nat %updateState_borrowedTokens) (int %updateState_interestIndex))))) (pair (pair (pair (bool %updateState_isLiquidated) (address %updateState_ovenAddress)) (pair (int %updateState_stabilityFeeTokens) (pair (nat %withdraw_borrowedTokens) (bool %withdraw_liquidated)))) (pair (pair (mutez %withdraw_mutezToWithdraw) (pair (address %withdraw_ovenAddress) (nat %withdraw_ovenBalance))) (pair (address %withdraw_ownerAddress) (pair (int %withdraw_stabilityFeeTokens) (int %withdraw_vaultInterestIndex))))))) + }; \ No newline at end of file diff --git a/smart_contracts/token.py b/smart_contracts/token.py new file mode 100644 index 00000000..e58778d3 --- /dev/null +++ b/smart_contracts/token.py @@ -0,0 +1,573 @@ +# Fungible Assets - FA12 +# Inspired by https://gitlab.com/tzip/tzip/blob/master/A/FA1.2.md + +# This file is copied verbatim from http://smartpy.io/dev/?template=fa12.py on 11/02/2020. +# All changed lines are annotated with `CHANGED: ` + +import smartpy as sp + +# CHANGED: Import errors. +Errors = sp.import_script_from_url("file:common/errors.py") + +# CHANGED: Import address helpers +Addresses = sp.import_script_from_url("file:test-helpers/addresses.py") + +# CHANGED: Define a constant for the empty string in the metadata bigmap +METADATA_KEY = "" + +class FA12_core(sp.Contract): + def __init__(self, **extra_storage): + token_id = sp.nat(0) + + kusd_metadata = sp.map( + l = { + "name": sp.bytes('0x4b6f6c6962726920555344'), # Kolibri USD + "decimals": sp.bytes('0x3138'), # 18 + "symbol": sp.bytes('0x6b555344'), # kUSD + "icon": sp.bytes('0x2068747470733a2f2f6b6f6c696272692d646174612e73332e616d617a6f6e6177732e636f6d2f6c6f676f2e706e67') # https://kolibri-data.s3.amazonaws.com/logo.png + }, + tkey = sp.TString, + tvalue = sp.TBytes + ) + kusd_entry = (token_id, kusd_metadata) + token_metadata = sp.big_map( + l = { + token_id: kusd_entry, + }, + tkey = sp.TNat, + tvalue = sp.TPair(sp.TNat, sp.TMap(sp.TString, sp.TBytes)) + ) + + # Hexadecimal representation of: + # { name: " Kolibri Token Contract", "description": "FA1.2 Implementation of kUSD", "author": "Hover Labs", "homepage": "https://kolibri.finance", "interfaces": [ "TZIP-007-2021-01-29"] } + metadata_data = sp.bytes('0x7b206e616d653a2022204b6f6c6962726920546f6b656e20436f6e7472616374222c20226465736372697074696f6e223a20224641312e3220496d706c656d656e746174696f6e206f66206b555344222c2022617574686f72223a2022486f766572204c616273222c2022686f6d6570616765223a20202268747470733a2f2f6b6f6c696272692e66696e616e6365222c2022696e7465726661636573223a205b2022545a49502d3030372d323032312d30312d3239225d207d') + + metadata = sp.big_map( + l = { + "": sp.bytes('0x74657a6f732d73746f726167653a64617461'), # "tezos-storage:data" + "data": metadata_data + }, + tkey = sp.TString, + tvalue = sp.TBytes + ) + + self.exception_optimization_level = "DefaultUnit" + + self.init( + balances = sp.big_map(tvalue = sp.TRecord(approvals = sp.TMap(sp.TAddress, sp.TNat), balance = sp.TNat)), + totalSupply = 0, + # CHANGED: Include metadata and token_metadata bigmap in storage. + metadata = metadata, + token_metadata = token_metadata, + **extra_storage + ) + + @sp.entry_point + def transfer(self, params): + sp.set_type(params, sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress, value = sp.TNat).layout(("from_ as from", ("to_ as to", "value")))) + sp.verify(self.is_administrator(sp.sender) | + (~self.is_paused() & + ((params.from_ == sp.sender) | + (self.data.balances[params.from_].approvals[sp.sender] >= params.value))), Errors.TOKEN_NO_TRANSFER_PERMISSION) + self.addAddressIfNecessary(params.to_) + sp.verify(self.data.balances[params.from_].balance >= params.value, Errors.TOKEN_INSUFFICIENT_BALANCE) + self.data.balances[params.from_].balance = sp.as_nat(self.data.balances[params.from_].balance - params.value) + self.data.balances[params.to_].balance += params.value + sp.if (params.from_ != sp.sender) & (~self.is_administrator(sp.sender)): + self.data.balances[params.from_].approvals[sp.sender] = sp.as_nat(self.data.balances[params.from_].approvals[sp.sender] - params.value) + + @sp.entry_point + def approve(self, params): + sp.set_type(params, sp.TRecord(spender = sp.TAddress, value = sp.TNat).layout(("spender", "value"))) + sp.verify(~self.is_paused()) + alreadyApproved = self.data.balances[sp.sender].approvals.get(params.spender, 0) + sp.verify((alreadyApproved == 0) | (params.value == 0), Errors.TOKEN_UNSAFE_ALLOWANCE_CHANGE) + self.data.balances[sp.sender].approvals[params.spender] = params.value + + def addAddressIfNecessary(self, address): + sp.if ~ self.data.balances.contains(address): + self.data.balances[address] = sp.record(balance = 0, approvals = {}) + + @sp.view(sp.TNat) + def getBalance(self, params): + sp.result(self.data.balances[params].balance) + + @sp.view(sp.TNat) + def getAllowance(self, params): + sp.result(self.data.balances[params.owner].approvals[params.spender]) + + @sp.view(sp.TNat) + def getTotalSupply(self, params): + sp.set_type(params, sp.TUnit) + sp.result(self.data.totalSupply) + + # this is not part of the standard but can be supported through inheritance. + def is_paused(self): + return sp.bool(False) + + # this is not part of the standard but can be supported through inheritance. + def is_administrator(self, sender): + return sp.bool(False) + +class FA12_mint_burn(FA12_core): + @sp.entry_point + def mint(self, params): + sp.set_type(params, sp.TRecord(address = sp.TAddress, value = sp.TNat)) + sp.verify(self.is_administrator(sp.sender), Errors.TOKEN_NOT_ADMINISTRATOR) + self.addAddressIfNecessary(params.address) + self.data.balances[params.address].balance += params.value + self.data.totalSupply += params.value + + # CHANGED: Verify that the debt ceiling is not passed. + sp.verify(self.data.totalSupply <= self.data.debtCeiling, Errors.DEBT_CEILING) + + @sp.entry_point + def burn(self, params): + sp.set_type(params, sp.TRecord(address = sp.TAddress, value = sp.TNat)) + sp.verify(self.is_administrator(sp.sender), Errors.TOKEN_NOT_ADMINISTRATOR) + sp.verify(self.data.balances[params.address].balance >= params.value, Errors.TOKEN_INSUFFICIENT_BALANCE) + self.data.balances[params.address].balance = sp.as_nat(self.data.balances[params.address].balance - params.value) + self.data.totalSupply = sp.as_nat(self.data.totalSupply - params.value) + +class FA12_administrator(FA12_core): + def is_administrator(self, sender): + return sender == self.data.administrator + + @sp.entry_point + def setAdministrator(self, params): + sp.set_type(params, sp.TAddress) + + # CHANGED: Allow the governor to set the administrator, instead of the administrator. + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.administrator = params + + @sp.view(sp.TAddress) + def getAdministrator(self, params): + sp.set_type(params, sp.TUnit) + sp.result(self.data.administrator) + +class FA12_pause(FA12_core): + def is_paused(self): + return self.data.paused + + @sp.entry_point + def setPause(self, params): + sp.set_type(params, sp.TBool) + sp.verify(self.is_administrator(sp.sender), Errors.TOKEN_NOT_ADMINISTRATOR) + self.data.paused = params + +class FA12(FA12_mint_burn, FA12_administrator, FA12_pause, FA12_core): + def __init__( + self, + # CHANGED: Assign a default value to `admin` + admin = Addresses.GOVERNOR_ADDRESS, + + # CHANGED: Add a governor contract. + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + + # CHANGED: Add a debt ceiling + debtCeiling = sp.nat(1000000000000000000000) # $1000 + ): + FA12_core.__init__( + self, + paused = False, + administrator = admin, + governorContractAddress = governorContractAddress, + debtCeiling = debtCeiling + ) + + # CHANGED: Add entrypoint to update governor. + # Update the governor contract. + @sp.entry_point + def setGovernorContract(self, newGovernorContractAddress): + sp.set_type(newGovernorContractAddress, sp.TAddress) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.governorContractAddress = newGovernorContractAddress + + # CHANGED: Add entrypoint to set debt ceiling. + @sp.entry_point + def setDebtCeiling(self, newDebtCeiling): + sp.set_type(newDebtCeiling, sp.TNat) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.debtCeiling = newDebtCeiling + + # CHANGED: Allow governor to update contract metadata. + @sp.entry_point + def updateContractMetadata(self, params): + sp.set_type(params, sp.TPair(sp.TString, sp.TBytes)) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + key = sp.fst(params) + value = sp.snd(params) + self.data.metadata[key] = value + + # CHANGED: Allow governor to update token metadata. + @sp.entry_point + def updateTokenMetadata(self, params): + sp.set_type(params, sp.TPair(sp.TNat, sp.TMap(sp.TString, sp.TBytes))) + + sp.verify(sp.sender == self.data.governorContractAddress, message = Errors.NOT_GOVERNOR) + self.data.token_metadata[0] = params + +class Viewer(sp.Contract): + def __init__(self, t): + self.init(last = sp.none) + self.init_type(sp.TRecord(last = sp.TOption(t))) + @sp.entry_point + def target(self, params): + self.data.last = sp.some(params) + + +# Only run tests if this file is main. +if __name__ == "__main__": + + if "templates" not in __name__: + @sp.add_test(name = "FA12") + def test(): + + scenario = sp.test_scenario() + scenario.h1("FA1.2 template - Fungible assets") + + scenario.table_of_contents() + + # sp.test_account generates ED25519 key-pairs deterministically: + admin = sp.test_account("Administrator") + alice = sp.test_account("Alice") + bob = sp.test_account("Robert") + + # Let's display the accounts: + scenario.h1("Accounts") + scenario.show([admin, alice, bob]) + + scenario.h1("Contract") + c1 = FA12(admin.address) + + scenario.h1("Entry points") + scenario += c1 + scenario.h2("Admin mints a few coins") + scenario += c1.mint(address = alice.address, value = 12).run(sender = admin) + scenario += c1.mint(address = alice.address, value = 3).run(sender = admin) + scenario += c1.mint(address = alice.address, value = 3).run(sender = admin) + scenario.h2("Alice transfers to Bob") + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 4).run(sender = alice) + scenario.verify(c1.data.balances[alice.address].balance == 14) + scenario.h2("Bob tries to transfer from Alice but he doesn't have her approval") + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 4).run(sender = bob, valid = False) + scenario.h2("Alice approves Bob and Bob transfers") + scenario += c1.approve(spender = bob.address, value = 5).run(sender = alice) + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 4).run(sender = bob) + scenario.h2("Bob tries to over-transfer from Alice") + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 4).run(sender = bob, valid = False) + scenario.h2("Admin burns Bob token") + scenario += c1.burn(address = bob.address, value = 1).run(sender = admin) + scenario.verify(c1.data.balances[alice.address].balance == 10) + scenario.h2("Alice tries to burn Bob token") + scenario += c1.burn(address = bob.address, value = 1).run(sender = alice, valid = False) + scenario.h2("Admin pauses the contract and Alice cannot transfer anymore") + scenario += c1.setPause(True).run(sender = admin) + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 4).run(sender = alice, valid = False) + scenario.verify(c1.data.balances[alice.address].balance == 10) + scenario.h2("Admin transfers while on pause") + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 1).run(sender = admin) + scenario.h2("Admin unpauses the contract and transfers are allowed") + scenario += c1.setPause(False).run(sender = admin) + scenario.verify(c1.data.balances[alice.address].balance == 9) + scenario += c1.transfer(from_ = alice.address, to_ = bob.address, value = 1).run(sender = alice) + + scenario.verify(c1.data.totalSupply == 17) + scenario.verify(c1.data.balances[alice.address].balance == 8) + scenario.verify(c1.data.balances[bob.address].balance == 9) + + scenario.h1("Views") + scenario.h2("Balance") + view_balance = Viewer(sp.TNat) + scenario += view_balance + scenario += c1.getBalance((alice.address, view_balance.typed)) + scenario.verify_equal(view_balance.data.last, sp.some(8)) + + scenario.h2("Administrator") + view_administrator = Viewer(sp.TAddress) + scenario += view_administrator + scenario += c1.getAdministrator((sp.unit, view_administrator.typed)) + scenario.verify_equal(view_administrator.data.last, sp.some(admin.address)) + + scenario.h2("Total Supply") + view_totalSupply = Viewer(sp.TNat) + scenario += view_totalSupply + scenario += c1.getTotalSupply((sp.unit, view_totalSupply.typed)) + scenario.verify_equal(view_totalSupply.data.last, sp.some(17)) + + scenario.h2("Allowance") + view_allowance = Viewer(sp.TNat) + scenario += view_allowance + scenario += c1.getAllowance((sp.record(owner = alice.address, spender = bob.address), view_allowance.typed)) + scenario.verify_equal(view_allowance.data.last, sp.some(1)) + + # CHANGED: Additional tests added below this line. + + ################################################################ + # mint + ################################################################ + + Dummy = sp.import_script_from_url("file:test-helpers/dummy-contract.py") + + @sp.add_test(name="mint - respects debt ceiling") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + debtCeiling = 100 + token = FA12( + admin = Addresses.GOVERNOR_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + debtCeiling = debtCeiling + ) + scenario += token + + # AND a token holder. + tokenHolder = Dummy.DummyContract() + scenario += tokenHolder + + # WHEN tokens are minted to the debt ceiling. + mintParam = sp.record(address= tokenHolder.address, value= debtCeiling) + scenario += token.mint(mintParam).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN tokens are minted successfully + scenario.verify(token.data.balances[tokenHolder.address].balance == debtCeiling) + scenario.verify(token.data.totalSupply == debtCeiling) + + # WHEN another mint is called THEN the call fails + mintParam = sp.record(address= tokenHolder.address, value= 1) + scenario += token.mint(mintParam).run( + sender = Addresses.GOVERNOR_ADDRESS, + valid = False + ) + + ################################################################ + # setDebtCeiling + ################################################################ + + @sp.add_test(name="setDebtCeiling - succeeds when called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + debtCeiling = 123 + ) + scenario += token + + # WHEN the setDebtCeiling is called with a new ceiling + newDebtCeiling = 456 + scenario += token.setDebtCeiling(newDebtCeiling).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN the contract is updated. + scenario.verify(token.data.debtCeiling == newDebtCeiling) + + @sp.add_test(name="setDebtCeiling - fails when not called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + debtCeiling = 123 + ) + scenario += token + + # WHEN the setDebtCeiling is called by someone who isn't the governor THEN the call fails + newDebtCeiling = 456 + scenario += token.setDebtCeiling(newDebtCeiling).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # updateContractMetadata + ################################################################ + + @sp.add_test(name="updateContractMetadata - succeeds when called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ) + scenario += token + + # WHEN the updateContractMetadata is called with a new locator + locatorKey = "" + newLocator = sp.bytes('0x1234567890') + scenario += token.updateContractMetadata((locatorKey, newLocator)).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN the contract is updated. + scenario.verify(token.data.metadata[locatorKey] == newLocator) + + @sp.add_test(name="updateContractMetadata - fails when not called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ) + scenario += token + + # WHEN the updateContractMetadata is called by someone who isn't the governor THEN the call fails + locatorKey = "" + newLocator = sp.bytes('0x1234567890') + scenario += token.updateContractMetadata((locatorKey, newLocator)).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # updateTokenMetadata + ################################################################ + + @sp.add_test(name="updateTokenMetadata - succeeds when called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ) + scenario += token + + # WHEN the updateTokenMetadata is called with a new data set. + newKey = "new" + newValue = sp.bytes('0x123456') + newMap = sp.map( + l = { + newKey: newValue + }, + tkey = sp.TString, + tvalue = sp.TBytes + ) + newData = (sp.nat(0), newMap) + + scenario += token.updateTokenMetadata(newData).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN the contract is updated. + tokenMetadata = token.data.token_metadata[0] + tokenId = sp.fst(tokenMetadata) + tokenMetadataMap = sp.snd(tokenMetadata) + + scenario.verify(tokenId == sp.nat(0)) + scenario.verify(tokenMetadataMap[newKey] == newValue) + + @sp.add_test(name="updateTokenMetadata - fails when not called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS, + ) + scenario += token + + # WHEN the updateTokenMetadata is called by someone who isn't the governor THEN the call fails + newMap = sp.map( + l = { + "new": sp.bytes('0x123456') + }, + tkey = sp.TString, + tvalue = sp.TBytes + ) + newData = (sp.nat(0), newMap) + scenario += token.updateTokenMetadata(newData).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + ################################################################ + # setAdministrator + ################################################################ + + @sp.add_test(name="setAdministrator - succeeds when called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + admin = Addresses.FUND_ADMINISTRATOR_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ) + scenario += token + + # WHEN the setAdministrator is called with a new contract + scenario += token.setAdministrator(Addresses.ROTATED_ADDRESS).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN the contract is updated. + scenario.verify(token.data.administrator == Addresses.ROTATED_ADDRESS) + + @sp.add_test(name="setAdministrator - fails when not called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + admin = Addresses.FUND_ADMINISTRATOR_ADDRESS, + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ) + scenario += token + + # WHEN the setAdministrator is called by someone who isn't the governor THEN the call fails + scenario += token.setAdministrator(Addresses.ROTATED_ADDRESS).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) + + + ################################################################ + # setGovernorContract + ################################################################ + + @sp.add_test(name="setGovernorContract - succeeds when called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ) + scenario += token + + # WHEN the setGovernorContract is called with a new contract + scenario += token.setGovernorContract(Addresses.ROTATED_ADDRESS).run( + sender = Addresses.GOVERNOR_ADDRESS, + ) + + # THEN the contract is updated. + scenario.verify(token.data.governorContractAddress == Addresses.ROTATED_ADDRESS) + + @sp.add_test(name="setGovernorContract - fails when not called by governor") + def test(): + # GIVEN a Token contract + scenario = sp.test_scenario() + + token = FA12( + governorContractAddress = Addresses.GOVERNOR_ADDRESS + ) + scenario += token + + # WHEN the setGovernorContract is called by someone who isn't the governor THEN the call fails + scenario += token.setGovernorContract(Addresses.ROTATED_ADDRESS).run( + sender = Addresses.NULL_ADDRESS, + valid = False + ) diff --git a/smart_contracts/token.tz b/smart_contracts/token.tz new file mode 100644 index 00000000..64f541e2 --- /dev/null +++ b/smart_contracts/token.tz @@ -0,0 +1,1125 @@ +parameter (or (or (or (pair %approve (address %spender) (nat %value)) (or (pair %burn (address %address) (nat %value)) (pair %getAdministrator unit (contract address)))) (or (or (pair %getAllowance (pair (address %owner) (address %spender)) (contract nat)) (pair %getBalance address (contract nat))) (or (pair %getTotalSupply unit (contract nat)) (pair %mint (address %address) (nat %value))))) (or (or (address %setAdministrator) (or (nat %setDebtCeiling) (address %setGovernorContract))) (or (or (bool %setPause) (pair %transfer (address %from) (pair (address %to) (nat %value)))) (or (pair %updateContractMetadata string bytes) (pair %updateTokenMetadata nat (map string bytes)))))); +storage (pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)))); +code + { + DUP; # pair @parameter @storage : pair @parameter @storage + CDR; # @storage : pair @parameter @storage + SWAP; # pair @parameter @storage : @storage + CAR; # @parameter : @storage + IF_LEFT + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%approve + # == approve == + # sp.verify(~ self.data.paused) # @storage : @parameter%approve + DUP; # @storage : @storage : @parameter%approve + DUG 2; # @storage : @parameter%approve : @storage + CDADR; # bool : @parameter%approve : @storage + IF + { + UNIT; # unit : @parameter%approve : @storage + FAILWITH; # FAILED + } + {}; # @parameter%approve : @storage + # sp.verify((self.data.balances[sp.sender].approvals.get(params.spender, default_value = 0) == 0) | (params.value == 0), message = 23) # @parameter%approve : @storage + PUSH nat 0; # nat : @parameter%approve : @storage + DIG 2; # @storage : nat : @parameter%approve + DUP; # @storage : @storage : nat : @parameter%approve + DUG 3; # @storage : nat : @parameter%approve : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%approve : @storage + SENDER; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%approve : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%approve : @storage + IF_SOME + { + # of_some: Get-item:83 # @some : nat : @parameter%approve : @storage + } + { + UNIT; # unit : nat : @parameter%approve : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%approve : @storage + CAR; # map address nat : nat : @parameter%approve : @storage + DIG 2; # @parameter%approve : map address nat : nat : @storage + DUP; # @parameter%approve : @parameter%approve : map address nat : nat : @storage + DUG 3; # @parameter%approve : map address nat : nat : @parameter%approve : @storage + CAR; # address : map address nat : nat : @parameter%approve : @storage + GET; # option nat : nat : @parameter%approve : @storage + IF_SOME + { + # of_some: Get-item:83 # @some : nat : @parameter%approve : @storage + } + { + PUSH nat 0; # nat : nat : @parameter%approve : @storage + }; # @some : nat : @parameter%approve : @storage + COMPARE; # int : @parameter%approve : @storage + EQ; # bool : @parameter%approve : @storage + IF + { + PUSH bool True; # bool : @parameter%approve : @storage + } + { + DUP; # @parameter%approve : @parameter%approve : @storage + CDR; # nat : @parameter%approve : @storage + PUSH nat 0; # nat : nat : @parameter%approve : @storage + COMPARE; # int : @parameter%approve : @storage + EQ; # bool : @parameter%approve : @storage + }; # bool : @parameter%approve : @storage + IF + {} + { + PUSH int 23; # int : @parameter%approve : @storage + FAILWITH; # FAILED + }; # @parameter%approve : @storage + SWAP; # @storage : @parameter%approve + # self.data.balances[sp.sender].approvals[params.spender] = params.value # @storage : @parameter%approve + DUP; # @storage : @storage : @parameter%approve + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%approve + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUP; # big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + SENDER; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUP; # address : address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUG 2; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + GET; # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DUP; # @some : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CDR; # nat : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + SWAP; # @some : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + CAR; # map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%approve + DIG 7; # @parameter%approve : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%approve : @parameter%approve : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + CAR; # address : @parameter%approve : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # @parameter%approve : address : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + CDR; # nat : address : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SOME; # option nat : address : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : option nat : map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + UPDATE; # map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (map address nat) nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SOME; # option (pair (map address nat) nat) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : option (pair (map address nat) nat) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + NIL operation; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%burn + # == burn == + # sp.verify(sp.sender == self.data.administrator, message = 24) # @storage : @parameter%burn + DUP; # @storage : @storage : @parameter%burn + DUG 2; # @storage : @parameter%burn : @storage + CAAAR; # address : @parameter%burn : @storage + SENDER; # address : address : @parameter%burn : @storage + COMPARE; # int : @parameter%burn : @storage + EQ; # bool : @parameter%burn : @storage + IF + {} + { + PUSH int 24; # int : @parameter%burn : @storage + FAILWITH; # FAILED + }; # @parameter%burn : @storage + # sp.verify(self.data.balances[params.address].balance >= params.value, message = 23) # @parameter%burn : @storage + DUP; # @parameter%burn : @parameter%burn : @storage + CDR; # nat : @parameter%burn : @storage + DIG 2; # @storage : nat : @parameter%burn + DUP; # @storage : @storage : nat : @parameter%burn + DUG 3; # @storage : nat : @parameter%burn : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%burn : @storage + DIG 2; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUP; # @parameter%burn : @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUG 3; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%burn : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%burn : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%burn : @storage + IF_SOME + { + # of_some: Get-item:128 # @some : nat : @parameter%burn : @storage + } + { + UNIT; # unit : nat : @parameter%burn : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%burn : @storage + CDR; # nat : nat : @parameter%burn : @storage + COMPARE; # int : @parameter%burn : @storage + GE; # bool : @parameter%burn : @storage + IF + {} + { + PUSH int 23; # int : @parameter%burn : @storage + FAILWITH; # FAILED + }; # @parameter%burn : @storage + SWAP; # @storage : @parameter%burn + # self.data.balances[params.address].balance = sp.as_nat(self.data.balances[params.address].balance - params.value) # @storage : @parameter%burn + DUP; # @storage : @storage : @parameter%burn + DUG 2; # @storage : @parameter%burn : @storage + DUP; # @storage : @storage : @parameter%burn : @storage + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%burn : @storage + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DUP; # big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DIG 5; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUP; # @parameter%burn : @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUG 6; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DUP; # address : address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DUG 2; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CAR; # map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DIG 6; # @parameter%burn : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUP; # @parameter%burn : @parameter%burn : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUG 7; # @parameter%burn : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + CDR; # nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn : @storage + DIG 8; # @storage : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + DIG 8; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%burn : @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 9; # @parameter%burn : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + IF_SOME + { + # of_some: Get-item:129 # @some : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + } + { + UNIT; # unit : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + FAILWITH; # FAILED + }; # @some : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + CDR; # nat : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + SUB; # int : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + ISNAT; # option nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + IF_SOME + {} + { + UNIT; # unit : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + FAILWITH; # FAILED + }; # @some : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + SWAP; # map address nat : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + PAIR; # pair (map address nat) @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + SOME; # option (pair (map address nat) @some) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + SWAP; # address : option (pair (map address nat) @some) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%burn + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn + # self.data.totalSupply = sp.as_nat(self.data.totalSupply - params.value) # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn + DUG 2; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # pair (big_map %metadata string bytes) (bool %paused) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDAR; # big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%burn : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DIG 3; # @parameter%burn : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DIG 4; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + CDDDR; # nat : nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SUB; # int : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + ISNAT; # option nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + IF_SOME + {} + { + UNIT; # unit : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + FAILWITH; # FAILED + }; # @some : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # big_map nat (pair nat (map string bytes)) : @some : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (big_map nat (pair nat (map string bytes))) @some : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (big_map %metadata string bytes) (bool %paused) : pair (big_map nat (pair nat (map string bytes))) @some : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) @some) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) @some) + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) @some)) + NIL operation; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) @some)) + } + { + SWAP; # @storage : @parameter%getAdministrator + # == getAdministrator == + # sp.result(self.data.administrator) # @storage : @parameter%getAdministrator + DUP; # @storage : @storage : @parameter%getAdministrator + DUG 2; # @storage : @parameter%getAdministrator : @storage + CAAAR; # address : @parameter%getAdministrator : @storage + # sp.transfer(__s1.value, sp.tez(0), sp.snd(params)) # address : @parameter%getAdministrator : @storage + NIL operation; # list operation : address : @parameter%getAdministrator : @storage + DIG 2; # @parameter%getAdministrator : list operation : address : @storage + CDR; # contract address : list operation : address : @storage + PUSH mutez 0; # mutez : contract address : list operation : address : @storage + DIG 3; # address : mutez : contract address : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) @some)) + }; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%getAllowance + # == getAllowance == + # sp.result(self.data.balances[sp.fst(params).owner].approvals[sp.fst(params).spender]) # @storage : @parameter%getAllowance + DUP; # @storage : @storage : @parameter%getAllowance + DUG 2; # @storage : @parameter%getAllowance : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getAllowance : @storage + SWAP; # @parameter%getAllowance : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUP; # @parameter%getAllowance : @parameter%getAllowance : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUG 2; # @parameter%getAllowance : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getAllowance : @storage + CAAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getAllowance : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : @parameter%getAllowance : @storage + IF_SOME + { + # of_some: Get-item:97 # @some : @parameter%getAllowance : @storage + } + { + UNIT; # unit : @parameter%getAllowance : @storage + FAILWITH; # FAILED + }; # @some : @parameter%getAllowance : @storage + CAR; # map address nat : @parameter%getAllowance : @storage + SWAP; # @parameter%getAllowance : map address nat : @storage + DUP; # @parameter%getAllowance : @parameter%getAllowance : map address nat : @storage + DUG 2; # @parameter%getAllowance : map address nat : @parameter%getAllowance : @storage + CADR; # address : map address nat : @parameter%getAllowance : @storage + GET; # option nat : @parameter%getAllowance : @storage + IF_SOME + { + # of_some: Get-item:97 # @some : @parameter%getAllowance : @storage + } + { + UNIT; # unit : @parameter%getAllowance : @storage + FAILWITH; # FAILED + }; # @some : @parameter%getAllowance : @storage + # sp.transfer(__s2.value, sp.tez(0), sp.snd(params)) # @some : @parameter%getAllowance : @storage + NIL operation; # list operation : @some : @parameter%getAllowance : @storage + DIG 2; # @parameter%getAllowance : list operation : @some : @storage + CDR; # contract nat : list operation : @some : @storage + PUSH mutez 0; # mutez : contract nat : list operation : @some : @storage + DIG 3; # @some : mutez : contract nat : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%getBalance + # == getBalance == + # sp.result(self.data.balances[sp.fst(params)].balance) # @storage : @parameter%getBalance + DUP; # @storage : @storage : @parameter%getBalance + DUG 2; # @storage : @parameter%getBalance : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getBalance : @storage + SWAP; # @parameter%getBalance : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUP; # @parameter%getBalance : @parameter%getBalance : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUG 2; # @parameter%getBalance : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getBalance : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%getBalance : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : @parameter%getBalance : @storage + IF_SOME + { + # of_some: Get-item:93 # @some : @parameter%getBalance : @storage + } + { + UNIT; # unit : @parameter%getBalance : @storage + FAILWITH; # FAILED + }; # @some : @parameter%getBalance : @storage + CDR; # nat : @parameter%getBalance : @storage + # sp.transfer(__s3.value, sp.tez(0), sp.snd(params)) # nat : @parameter%getBalance : @storage + NIL operation; # list operation : nat : @parameter%getBalance : @storage + DIG 2; # @parameter%getBalance : list operation : nat : @storage + CDR; # contract nat : list operation : nat : @storage + PUSH mutez 0; # mutez : contract nat : list operation : nat : @storage + DIG 3; # nat : mutez : contract nat : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + }; # list operation : @storage + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%getTotalSupply + # == getTotalSupply == + # sp.result(self.data.totalSupply) # @storage : @parameter%getTotalSupply + DUP; # @storage : @storage : @parameter%getTotalSupply + DUG 2; # @storage : @parameter%getTotalSupply : @storage + CDDDR; # nat : @parameter%getTotalSupply : @storage + # sp.transfer(__s4.value, sp.tez(0), sp.snd(params)) # nat : @parameter%getTotalSupply : @storage + NIL operation; # list operation : nat : @parameter%getTotalSupply : @storage + DIG 2; # @parameter%getTotalSupply : list operation : nat : @storage + CDR; # contract nat : list operation : nat : @storage + PUSH mutez 0; # mutez : contract nat : list operation : nat : @storage + DIG 3; # nat : mutez : contract nat : list operation : @storage + TRANSFER_TOKENS; # operation : list operation : @storage + CONS; # list operation : @storage + } + { + SWAP; # @storage : @parameter%mint + # == mint == + # sp.verify(sp.sender == self.data.administrator, message = 24) # @storage : @parameter%mint + DUP; # @storage : @storage : @parameter%mint + DUG 2; # @storage : @parameter%mint : @storage + CAAAR; # address : @parameter%mint : @storage + SENDER; # address : address : @parameter%mint : @storage + COMPARE; # int : @parameter%mint : @storage + EQ; # bool : @parameter%mint : @storage + IF + {} + { + PUSH int 24; # int : @parameter%mint : @storage + FAILWITH; # FAILED + }; # @parameter%mint : @storage + SWAP; # @storage : @parameter%mint + # if ~ (self.data.balances.contains(params.address)): # @storage : @parameter%mint + DUP; # @storage : @storage : @parameter%mint + DUG 2; # @storage : @parameter%mint : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%mint : @storage + SWAP; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUP; # @parameter%mint : @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUG 2; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%mint : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%mint : @storage + MEM; # bool : @parameter%mint : @storage + IF + {} + { + SWAP; # @storage : @parameter%mint + # self.data.balances[params.address] = sp.record(approvals = {}, balance = 0) # @storage : @parameter%mint + DUP; # @storage : @storage : @parameter%mint + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%mint + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DIG 4; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%mint : @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 5; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)); # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # address : option (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + UPDATE; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair address (big_map address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair (pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%mint + SWAP; # @parameter%mint : pair (pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # @parameter%mint : @storage + SWAP; # @storage : @parameter%mint + # self.data.balances[params.address].balance += params.value # @storage : @parameter%mint + DUP; # @storage : @storage : @parameter%mint + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%mint + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DIG 5; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%mint : @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 6; # @parameter%mint : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # address : address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUG 2; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + GET; # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DUP; # @some : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CAR; # map address nat : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # @some : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + DIG 7; # @parameter%mint : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%mint : @parameter%mint : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 8; # @parameter%mint : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + CDR; # nat : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + ADD; # nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # map address nat : nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair (map address nat) nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SOME; # option (pair (map address nat) nat) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # address : option (pair (map address nat) nat) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%mint + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%mint + # self.data.totalSupply += params.value # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%mint + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%mint + CAR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%mint + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + DUP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + CAR; # pair (big_map %metadata string bytes) (bool %paused) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + SWAP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + CDR; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + DUP; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + CAR; # big_map nat (pair nat (map string bytes)) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + SWAP; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + CDR; # nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%mint + DIG 4; # @parameter%mint : nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + CDR; # nat : nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + ADD; # nat : big_map nat (pair nat (map string bytes)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (big_map nat (pair nat (map string bytes))) nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (big_map %metadata string bytes) (bool %paused) : pair (big_map nat (pair nat (map string bytes))) nat : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat) + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + # sp.verify(self.data.totalSupply <= self.data.debtCeiling, message = 20) # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + CADAR; # nat : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) : nat + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) : nat + DUG 2; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) : nat : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + CDDDR; # nat : nat : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + COMPARE; # int : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + LE; # bool : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + IF + {} + { + PUSH int 20; # int : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + FAILWITH; # FAILED + }; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + NIL operation; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + }; # list operation : @storage + }; # list operation : @storage + }; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setAdministrator + # == setAdministrator == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setAdministrator + DUP; # @storage : @storage : @parameter%setAdministrator + DUG 2; # @storage : @parameter%setAdministrator : @storage + CADDR; # address : @parameter%setAdministrator : @storage + SENDER; # address : address : @parameter%setAdministrator : @storage + COMPARE; # int : @parameter%setAdministrator : @storage + EQ; # bool : @parameter%setAdministrator : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setAdministrator : @storage + FAILWITH; # FAILED + }; # @parameter%setAdministrator : @storage + SWAP; # @storage : @parameter%setAdministrator + # self.data.administrator = params # @storage : @parameter%setAdministrator + DUP; # @storage : @storage : @parameter%setAdministrator + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%setAdministrator + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + CADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setAdministrator + DIG 3; # @parameter%setAdministrator : big_map address (pair (map %approvals address nat) (nat %balance)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%setDebtCeiling + # == setDebtCeiling == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setDebtCeiling + DUP; # @storage : @storage : @parameter%setDebtCeiling + DUG 2; # @storage : @parameter%setDebtCeiling : @storage + CADDR; # address : @parameter%setDebtCeiling : @storage + SENDER; # address : address : @parameter%setDebtCeiling : @storage + COMPARE; # int : @parameter%setDebtCeiling : @storage + EQ; # bool : @parameter%setDebtCeiling : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setDebtCeiling : @storage + FAILWITH; # FAILED + }; # @parameter%setDebtCeiling : @storage + SWAP; # @storage : @parameter%setDebtCeiling + # self.data.debtCeiling = params # @storage : @parameter%setDebtCeiling + DUP; # @storage : @storage : @parameter%setDebtCeiling + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%setDebtCeiling + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + CDDR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setDebtCeiling + DIG 3; # @parameter%setDebtCeiling : address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair @parameter%setDebtCeiling address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair @parameter%setDebtCeiling address : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair @parameter%setDebtCeiling address) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair @parameter%setDebtCeiling address)) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + SWAP; # @storage : @parameter%setGovernorContract + # == setGovernorContract == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + DUG 2; # @storage : @parameter%setGovernorContract : @storage + CADDR; # address : @parameter%setGovernorContract : @storage + SENDER; # address : address : @parameter%setGovernorContract : @storage + COMPARE; # int : @parameter%setGovernorContract : @storage + EQ; # bool : @parameter%setGovernorContract : @storage + IF + {} + { + PUSH int 4; # int : @parameter%setGovernorContract : @storage + FAILWITH; # FAILED + }; # @parameter%setGovernorContract : @storage + SWAP; # @storage : @parameter%setGovernorContract + # self.data.governorContractAddress = params # @storage : @parameter%setGovernorContract + DUP; # @storage : @storage : @parameter%setGovernorContract + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%setGovernorContract + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + CDAR; # nat : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%setGovernorContract + DIG 3; # @parameter%setGovernorContract : nat : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # nat : @parameter%setGovernorContract : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair nat @parameter%setGovernorContract : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair nat @parameter%setGovernorContract : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair nat @parameter%setGovernorContract) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair nat @parameter%setGovernorContract)) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair @parameter%setDebtCeiling address)) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + IF_LEFT + { + SWAP; # @storage : @parameter%setPause + # == setPause == + # sp.verify(sp.sender == self.data.administrator, message = 24) # @storage : @parameter%setPause + DUP; # @storage : @storage : @parameter%setPause + DUG 2; # @storage : @parameter%setPause : @storage + CAAAR; # address : @parameter%setPause : @storage + SENDER; # address : address : @parameter%setPause : @storage + COMPARE; # int : @parameter%setPause : @storage + EQ; # bool : @parameter%setPause : @storage + IF + {} + { + PUSH int 24; # int : @parameter%setPause : @storage + FAILWITH; # FAILED + }; # @parameter%setPause : @storage + SWAP; # @storage : @parameter%setPause + # self.data.paused = params # @storage : @parameter%setPause + DUP; # @storage : @storage : @parameter%setPause + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @storage : @parameter%setPause + SWAP; # @storage : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + DUP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + CDR; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + SWAP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + CAAR; # big_map string bytes : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%setPause + DIG 3; # @parameter%setPause : big_map string bytes : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # big_map string bytes : @parameter%setPause : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (big_map string bytes) @parameter%setPause : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (pair (big_map string bytes) @parameter%setPause) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map string bytes) @parameter%setPause) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map string bytes) @parameter%setPause) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + SWAP; # @storage : @parameter%transfer + # == transfer == + # sp.verify((sp.sender == self.data.administrator) | ((~ self.data.paused) & ((params.from_ == sp.sender) | (self.data.balances[params.from_].approvals[sp.sender] >= params.value))), message = 22) # @storage : @parameter%transfer + DUP; # @storage : @storage : @parameter%transfer + DUG 2; # @storage : @parameter%transfer : @storage + CAAAR; # address : @parameter%transfer : @storage + SENDER; # address : address : @parameter%transfer : @storage + COMPARE; # int : @parameter%transfer : @storage + EQ; # bool : @parameter%transfer : @storage + IF + { + PUSH bool True; # bool : @parameter%transfer : @storage + } + { + SWAP; # @storage : @parameter%transfer + DUP; # @storage : @storage : @parameter%transfer + DUG 2; # @storage : @parameter%transfer : @storage + CDADR; # bool : @parameter%transfer : @storage + IF + { + PUSH bool False; # bool : @parameter%transfer : @storage + } + { + DUP; # @parameter%transfer : @parameter%transfer : @storage + CAR; # address : @parameter%transfer : @storage + SENDER; # address : address : @parameter%transfer : @storage + COMPARE; # int : @parameter%transfer : @storage + EQ; # bool : @parameter%transfer : @storage + IF + { + PUSH bool True; # bool : @parameter%transfer : @storage + } + { + DUP; # @parameter%transfer : @parameter%transfer : @storage + CDDR; # nat : @parameter%transfer : @storage + DIG 2; # @storage : nat : @parameter%transfer + DUP; # @storage : @storage : nat : @parameter%transfer + DUG 3; # @storage : nat : @parameter%transfer : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + DIG 2; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUG 3; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + IF_SOME + { + # of_some: Get-item:71 # @some : nat : @parameter%transfer : @storage + } + { + UNIT; # unit : nat : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%transfer : @storage + CAR; # map address nat : nat : @parameter%transfer : @storage + SENDER; # address : map address nat : nat : @parameter%transfer : @storage + GET; # option nat : nat : @parameter%transfer : @storage + IF_SOME + { + # of_some: Get-item:71 # @some : nat : @parameter%transfer : @storage + } + { + UNIT; # unit : nat : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%transfer : @storage + COMPARE; # int : @parameter%transfer : @storage + GE; # bool : @parameter%transfer : @storage + }; # bool : @parameter%transfer : @storage + }; # bool : @parameter%transfer : @storage + }; # bool : @parameter%transfer : @storage + IF + {} + { + PUSH int 22; # int : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @parameter%transfer : @storage + SWAP; # @storage : @parameter%transfer + # if ~ (self.data.balances.contains(params.to_)): # @storage : @parameter%transfer + DUP; # @storage : @storage : @parameter%transfer + DUG 2; # @storage : @parameter%transfer : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%transfer : @storage + SWAP; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : @storage + DUG 2; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%transfer : @storage + CDAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : @parameter%transfer : @storage + MEM; # bool : @parameter%transfer : @storage + IF + {} + { + SWAP; # @storage : @parameter%transfer + # self.data.balances[params.to_] = sp.record(approvals = {}, balance = 0) # @storage : @parameter%transfer + DUP; # @storage : @storage : @parameter%transfer + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%transfer + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DIG 4; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 5; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)); # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : option (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + UPDATE; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair address (big_map address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + SWAP; # @parameter%transfer : pair (pair (pair address (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # @parameter%transfer : @storage + # sp.verify(self.data.balances[params.from_].balance >= params.value, message = 23) # @parameter%transfer : @storage + DUP; # @parameter%transfer : @parameter%transfer : @storage + CDDR; # nat : @parameter%transfer : @storage + DIG 2; # @storage : nat : @parameter%transfer + DUP; # @storage : @storage : nat : @parameter%transfer + DUG 3; # @storage : nat : @parameter%transfer : @storage + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + DIG 2; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @storage + DUG 3; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : @parameter%transfer : @storage + IF_SOME + { + # of_some: Get-item:73 # @some : nat : @parameter%transfer : @storage + } + { + UNIT; # unit : nat : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @some : nat : @parameter%transfer : @storage + CDR; # nat : nat : @parameter%transfer : @storage + COMPARE; # int : @parameter%transfer : @storage + GE; # bool : @parameter%transfer : @storage + IF + {} + { + PUSH int 23; # int : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @parameter%transfer : @storage + SWAP; # @storage : @parameter%transfer + # self.data.balances[params.from_].balance = sp.as_nat(self.data.balances[params.from_].balance - params.value) # @storage : @parameter%transfer + DUP; # @storage : @storage : @parameter%transfer + DUG 2; # @storage : @parameter%transfer : @storage + DUP; # @storage : @storage : @parameter%transfer : @storage + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage : @parameter%transfer : @storage + SWAP; # @storage : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DUP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CAR; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DUP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CAR; # address : pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + SWAP; # pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance))) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CDR; # big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DUP; # big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DIG 5; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUG 6; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DUP; # address : address : big_map address (pair (map %approvals address nat) (nat %balance)) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DUG 2; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + GET; # option (pair (map %approvals address nat) (nat %balance)) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CAR; # map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DIG 6; # @parameter%transfer : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUP; # @parameter%transfer : @parameter%transfer : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @storage + DUG 7; # @parameter%transfer : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + CDDR; # nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : @storage + DIG 8; # @storage : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAADR; # big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DIG 8; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 9; # @parameter%transfer : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # address : big_map address (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + GET; # option (pair (map %approvals address nat) (nat %balance)) : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + IF_SOME + { + # of_some: Get-item:74 # @some : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + } + { + UNIT; # unit : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + FAILWITH; # FAILED + }; # @some : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # nat : nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SUB; # int : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + ISNAT; # option nat : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + IF_SOME + {} + { + UNIT; # unit : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + FAILWITH; # FAILED + }; # @some : map address nat : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # map address nat : @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (map address nat) @some : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SOME; # option (pair (map address nat) @some) : address : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : option (pair (map address nat) @some) : big_map address (pair (map %approvals address nat) (nat %balance)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + # self.data.balances[params.to_].balance += params.value # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # pair address (big_map address (pair (map address nat) nat)) : pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # address : pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # pair address (big_map address (pair (map address nat) nat)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DIG 5; # @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 6; # @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDAR; # address : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # address : address : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUG 2; # address : big_map address (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + GET; # option (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DUP; # @some : @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAR; # map address nat : @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # @some : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDR; # nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DIG 7; # @parameter%transfer : nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUP; # @parameter%transfer : @parameter%transfer : nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + DUG 8; # @parameter%transfer : nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CDDR; # nat : nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + ADD; # nat : map address nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (map address nat) nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SOME; # option (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : option (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + SWAP; # @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + # if (params.from_ != sp.sender) & (~ (sp.sender == self.data.administrator)): # @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # @parameter%transfer : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # address : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SENDER; # address : address : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + COMPARE; # int : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + NEQ; # bool : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + IF + { + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + DUG 2; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAAAR; # address : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SENDER; # address : address : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + COMPARE; # int : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + NEQ; # bool : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + PUSH bool False; # bool : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # bool : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + IF + { + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + # self.data.balances[params.from_].approvals[sp.sender] = sp.as_nat(self.data.balances[params.from_].approvals[sp.sender] - params.value) # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer + DUG 2; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # pair address (big_map address (pair (map address nat) nat)) : pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # address : pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # pair address (big_map address (pair (map address nat) nat)) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DIG 5; # @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # @parameter%transfer : @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUG 6; # @parameter%transfer : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # address : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # address : address : big_map address (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUG 2; # address : big_map address (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + GET; # option (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + IF_SOME + {} + { + UNIT; # unit : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + FAILWITH; # FAILED + }; # @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # @some : @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDR; # nat : @some : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SWAP; # @some : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CAR; # map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + SENDER; # address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DIG 8; # @parameter%transfer : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUP; # @parameter%transfer : @parameter%transfer : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DUG 9; # @parameter%transfer : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + CDDR; # nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + DIG 10; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + CAADR; # big_map address (pair (map address nat) nat) : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : @parameter%transfer + DIG 10; # @parameter%transfer : big_map address (pair (map address nat) nat) : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + CAR; # address : big_map address (pair (map address nat) nat) : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + GET; # option (pair (map address nat) nat) : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + IF_SOME + { + # of_some: Get-item:77 # @some : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + } + { + UNIT; # unit : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + FAILWITH; # FAILED + }; # @some : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + CAR; # map address nat : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SENDER; # address : map address nat : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + GET; # option nat : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + IF_SOME + { + # of_some: Get-item:77 # @some : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + } + { + UNIT; # unit : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + FAILWITH; # FAILED + }; # @some : nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SUB; # int : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + ISNAT; # option nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + IF_SOME + {} + { + UNIT; # unit : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + FAILWITH; # FAILED + }; # @some : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SOME; # option nat : address : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : option nat : map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + UPDATE; # map address nat : nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (map address nat) nat : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SOME; # option (pair (map address nat) nat) : address : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : option (pair (map address nat) nat) : big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + UPDATE; # big_map address (pair (map address nat) nat) : address : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + SWAP; # address : big_map address (pair (map address nat) nat) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair address (big_map address (pair (map address nat) nat)) : pair (nat %debtCeiling) (address %governorContractAddress) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + DROP; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map string bytes) @parameter%setPause) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + IF_LEFT + { + SWAP; # @storage : @parameter%updateContractMetadata + # == updateContractMetadata == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%updateContractMetadata + DUP; # @storage : @storage : @parameter%updateContractMetadata + DUG 2; # @storage : @parameter%updateContractMetadata : @storage + CADDR; # address : @parameter%updateContractMetadata : @storage + SENDER; # address : address : @parameter%updateContractMetadata : @storage + COMPARE; # int : @parameter%updateContractMetadata : @storage + EQ; # bool : @parameter%updateContractMetadata : @storage + IF + {} + { + PUSH int 4; # int : @parameter%updateContractMetadata : @storage + FAILWITH; # FAILED + }; # @parameter%updateContractMetadata : @storage + SWAP; # @storage : @parameter%updateContractMetadata + # self.data.metadata[sp.fst(params)] = sp.snd(params) # @storage : @parameter%updateContractMetadata + DUP; # @storage : @storage : @parameter%updateContractMetadata + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @storage : @parameter%updateContractMetadata + SWAP; # @storage : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + DUP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + CDR; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + SWAP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + CAR; # pair (big_map %metadata string bytes) (bool %paused) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + DUP; # pair (big_map %metadata string bytes) (bool %paused) : pair (big_map %metadata string bytes) (bool %paused) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + CDR; # bool : pair (big_map %metadata string bytes) (bool %paused) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + SWAP; # pair (big_map %metadata string bytes) (bool %paused) : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + CAR; # big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateContractMetadata + DIG 4; # @parameter%updateContractMetadata : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + DUP; # @parameter%updateContractMetadata : @parameter%updateContractMetadata : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + CAR; # string : @parameter%updateContractMetadata : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # @parameter%updateContractMetadata : string : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + CDR; # bytes : string : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SOME; # option bytes : string : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # string : option bytes : big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + UPDATE; # big_map string bytes : bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (big_map string bytes) bool : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (pair (big_map string bytes) bool) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map string bytes) bool) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) + PAIR; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map string bytes) bool) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + } + { + SWAP; # @storage : @parameter%updateTokenMetadata + # == updateTokenMetadata == + # sp.verify(sp.sender == self.data.governorContractAddress, message = 4) # @storage : @parameter%updateTokenMetadata + DUP; # @storage : @storage : @parameter%updateTokenMetadata + DUG 2; # @storage : @parameter%updateTokenMetadata : @storage + CADDR; # address : @parameter%updateTokenMetadata : @storage + SENDER; # address : address : @parameter%updateTokenMetadata : @storage + COMPARE; # int : @parameter%updateTokenMetadata : @storage + EQ; # bool : @parameter%updateTokenMetadata : @storage + IF + {} + { + PUSH int 4; # int : @parameter%updateTokenMetadata : @storage + FAILWITH; # FAILED + }; # @parameter%updateTokenMetadata : @storage + SWAP; # @storage : @parameter%updateTokenMetadata + # self.data.token_metadata[0] = params # @storage : @parameter%updateTokenMetadata + DUP; # @storage : @storage : @parameter%updateTokenMetadata + CAR; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @storage : @parameter%updateTokenMetadata + SWAP; # @storage : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + CDR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + DUP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + CAR; # pair (big_map %metadata string bytes) (bool %paused) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + SWAP; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + CDR; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + DUP; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + CDR; # nat : pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + SWAP; # pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + CAR; # big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + PUSH nat 0; # nat : big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : @parameter%updateTokenMetadata + DIG 5; # @parameter%updateTokenMetadata : nat : big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SOME; # option (pair nat (map string bytes)) : nat : big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # nat : option (pair nat (map string bytes)) : big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + UPDATE; # big_map nat (pair nat (map string bytes)) : nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (big_map nat (pair nat (map string bytes))) nat : pair (big_map %metadata string bytes) (bool %paused) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (big_map %metadata string bytes) (bool %paused) : pair (big_map nat (pair nat (map string bytes))) nat : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + PAIR; # pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat) : pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) + SWAP; # pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress)) : pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat) + PAIR; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map nat (pair nat (map string bytes))) nat)) + }; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map string bytes) bool) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair (address %administrator) (big_map %balances address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map string bytes) @parameter%setPause) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # pair (pair (pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + NIL operation; # list operation : pair (pair (pair @parameter%setAdministrator (big_map address (pair (map %approvals address nat) (nat %balance)))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + }; # list operation : pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply))) + PAIR; # pair (list operation) (pair (pair (pair address (big_map address (pair (map address nat) nat))) (pair (nat %debtCeiling) (address %governorContractAddress))) (pair (pair (big_map %metadata string bytes) (bool %paused)) (pair (big_map %token_metadata nat (pair nat (map string bytes))) (nat %totalSupply)))) + }; \ No newline at end of file